SAP Community - NW ABAP Gateway (OData)

[FSCM Collections]: Extend Manage Customer Line Items(App F0711) – OData MPC & DPC Code Enhancement

2024-10-06T22:52:27.703000+02:00

INTRODUCTION:

We have been given a requirement to add a set of custom fields to be extended in Manage Customer Line Items (App ID F0711) – Credit Management.

Challenge: The current system is an S4 HANA system version 2021, where CFL (Custom Fields and Logic) has been introduced but isn't available for the required App. Given is a SEGW Project with OData Services based on a Mapped Data Source (MDS). Redefinition w/ Extension of the project isn't possible, and we should not Overwrite the Std. Project.

Solution (Not a Clean-Core 😞) -This app is an OData Service application, so enhancing the MPC & DPC will be able to view the fields but can’t sort & filter the list as they are not part of the standard mapped CDS view and can’t be handled in SADL query options.

In this blog post, we will cover the required steps:

Extend the DDIC Structure, CDS View (if any) – Database Layer
Enhance the Service MPC (Model) – w/ BADI or Implicit (not recommended) Enhancement
Enhance the Service DPC (Data) – w/ BADI or Implicit (not recommended) Enhancement

to handle the requirement.

MAIN CONTENT:

From the Fiori Application Console (F12 / Cntrl+Shift+I) or Fiori Library, get the service name to open the respective SEGW Project and look for the Responsible Entity. You can check the Mapping for Ease
Open the DDIC Structure and look for the Persistent/Transient Include for our required, but here we found SQL Structure for CDS View itself.
So, let's better extend the required custom fields in there with the help of an APPEND structure.
Let’s try to find some BADI with Enhancement Spots first for OData, which we didn’t find for our App scenario. Hence, proceeded with Implicit Enhancement at MPC_EXT – Method DEFINE.

DATA: lo_entity_type TYPE REF TO /iwbep/if_mgw_odata_entity_typ, "#EC NEEDED
      lo_property    TYPE REF TO /iwbep/if_mgw_odata_property, "#EC NEEDED
      lv_text_ele    TYPE textpoolky,
      lv_char        TYPE i.

" Map the Entity Type
  lo_entity_type = model->get_entity_type( iv_entity_name = 'Item'  ).

" Loop For no of Custom fields
DO 2 TIMES.                                            "#EC CI_NESTED
    IF sy-index = 1.
      lo_entity_type->create_property( 
                    EXPORTING 
                      iv_property_name  = 'CollectionNotes1'
                      iv_abap_fieldname = 'ZZ_COMMENT1'
                    RECEIVING 
                      ro_property = DATA(lo_pro_item1) ). " LO_PROPERTY
      lv_text_ele = |CN1| . " Literal for Text-Element
    ELSE.
      lo_entity_type->create_property( 
                    EXPORTING 
                      iv_property_name  = 'CollectionNotes2'
                      iv_abap_fieldname = 'ZZ_COMMENT2'
                    RECEIVING 
                      ro_property = lo_pro_item1 ). " LO_PROPERTY
      lv_text_ele = |CN2| .
    ENDIF.

    lv_char = 128.

" Create the Property Details
    lo_pro_item1->set_type_edm_string( ).
    lo_pro_item1->set_maxlength( lv_char ).
    lo_pro_item->set_nullable( abap_true ).
    lo_pro_item1->set_updatable( abap_true ).
    lo_pro_item1->set_sortable( abap_false ). 
    lo_pro_item1->set_filterable( abap_false ).

" When to Map Front-End Labels different from ABAP field's DATA ELEMENT.
" Create Text CN1 & CN2 in Custom Class
    lo_pro_item1->set_label_from_text_element(
      EXPORTING
        iv_text_element_symbol = lv_text_ele
        iv_text_element_container zfscmcl_customer_line_comment=>gc_class_name " Constant - Custom Class Name 
**         io_object_ref          = me  " when Text-elements of MPC_EXT is used
        ).
    lo_pro_item1->set_internal_type( 'C' ).
    lo_pro_item1->set_internal_length( lv_char ). "( '128' ).
    CLEAR: lv_text_ele.
  ENDDO.

cl_afle_mpc_ext_utility_class=>adjust_model( model ). "AFLE

Adjusting the Model is necessary to handle action redefinition/addition. The front end can be handled by the Extension/Adaptation Project (if needed).

All the Data handling for the enhanced fields must be handled in this class methods to related entities & entity sets. Now Field values can be database stored or Run-time calculated. Here, Values are fetched at the Item level first. Values for multiple or single records have been fetched. So, create Enhancement at ITEMSET_GET_ENTITYSET:

************************************************************************
"Create Key Field Structure in Custom Class
  types:
    BEGIN OF gty_cli_key ,
        bukrs TYPE bukrs,
        belnr TYPE belnr_d,
        gjahr TYPE gjahr,
        buzei TYPE buzei,
        kunnr TYPE kunnr,
      END OF gty_cli_key .
  types:
    gtt_cli_key TYPE SORTED TABLE OF gty_cli_key WITH UNIQUE KEY bukrs belnr gjahr buzei .

************************************************************************
" In GET_ENTITYSET
    lt_cli_key = VALUE #( FOR ls_entity IN et_entityset 
                        WHERE ( companycode IS NOT INITIAL "#EC CI_STDSEQ
                                AND accountingdocument IS NOT INITIAL )
                              ( bukrs = ls_entity-companycode
                                belnr = ls_entity-accountingdocument
                                buzei = ls_entity-accountingdocumentitem
                                gjahr = ls_entity-fiscalyear )
                         ).
 
    IF lt_cli_key IS NOT INITIAL.
"Custom Method to process the data.
      DATA(lt_comments) = zfscmcl_customer_line_comment=>get_comments(  
                               it_cli_key = lt_cli_key ).
      UNASSIGN <ls_entity>.
      LOOP AT lt_comments ASSIGNING FIELD-SYMBOL(<ls_comments>).
        ASSIGN et_entityset[ 
                     companycode = <ls_comments>-company_code "#EC CI_STDSEQ
                     accountingdocument     = <ls_comments>-document_number
                     accountingdocumentitem = <ls_comments>-line_item_number
                     fiscalyear             = <ls_comments>-fiscal_year     
                   ] TO <ls_entity>.
        
          IF <ls_entity> IS ASSIGNED.
            <ls_entity>-zz_comment1 = <ls_comments>-comment1.
            <ls_entity>-zz_comment2 = <ls_comments>-comment2.
            UNASSIGN <ls_entity>.
           ENDIF.
      ENDLOOP.
      IF <ls_comments> IS ASSIGNED. UNASSIGN <ls_comments>. ENDIF.
      CLEAR: lt_comments.
    ENDIF.

4. Now check the fields in Adapt Settings. Better Clear Caches & Refresh Service Metdata with:

/IWBEP/CACHE_CLEANUP
IWFND/CACHE_CLEANUP
Refresh Metadata Layer at IWFND/MAINT_SERVICE

OData Versioning in SAP - Streamlining Parallel Development for Backend and Frontend Teams

2024-10-24T11:43:17.153000+02:00

OData (Open Data Protocol) versioning refers to managing the evolution of an OData service over time without disrupting existing clients. As services grow and change, updates may be necessary for various reasons, such as adding new features, enhancing performance, or fixing issues. OData versioning ensures these updates are implemented in a way that maintains compatibility with existing clients.

Every ODATA Service will have version by default it is 1 we can increment the version by 1,2 and 3 and so on. Changes are noted as version Initial Version -> Version 1 -> Version 2 -> Version3

Backend and frontend teams can develop independently. Backend can implement business changes and release them under a version (e.g., version 1), allowing the frontend team to catch up later.

Back End

Communication

Front End

Initial Version

Communication Happens through URI and URI doesn’t change

Initial Version

Version 1

They can complete their work and check with version 1 and 2 if we have and we don’t need versions after few days we can combine all versions in 1 and keep in one.

SEGW ->RUNTIME ARTIFACTS -> DPC CLASS -> MPC CLASS

Registered Service/ Technical Service name.

Registered Model / Technical Model name.

These two-play major role in achieving OData versioning.

Technical Model Name -> Technical Service Name – Version 1

Technical Service Name – Version 2

Technical Service Name – Version 3

Best Practices: In OData Service whatever design we do technical service name should be same if we make change in technical service name automatically it will change OData service URI.As the Technical Service Name remains consistent, the URI doesn’t change.

Example: If we have business scenario with 3 versions keep all 3 versions technical service names same.

Technical Model Name -> Technical Service Name – Version 1

DPC_EXT

Technical Service Name – Version 2

DPC_EXT -2

Technical Service Name – Version 3

DPC_EXT – 3

Logically we will have different DPC_EXT classes for versioning we are going to copy exiting DPC_EXT class and make it as a 1,2,3 only class name changes.

To register the services, create, change, delete we have a transaction /IWBEP/REG_SERVICE

To register the model, we have a transaction /IWBEP/REG_MODEL

Note: Model we are not going to change much.

Go to SEGW create a project with entity type and entity sets

Click on save and generate project

Runtime artifacts will be generated

Double click on the DPC_EXT and go to the methods select the entity set required and redefine the method.

Once we redefine the method it will be as below

Double click on the redefined method and write the code

To register the service, we need use transaction code /IWFND/MAINT_SERVICE and execute.

Click on Add Service

Specify Gateway system and Technical Service Name and click on Get Services

Select the Technical Service and click on Add selected service.

Select the Technical Service Name

Click on SAP Gateway Client

Select the entity set and execute.

Fetching Records with Different Versions

Using OData URI parameters (e.g., $Count), it is possible to test different versions and fetch different numbers of records.

10 Rows are fetched in V=1 using URI option

Copying Technical service Version1 to Version 2

Example: In version 2 we had more records to be fetched, and we can modify code in Version2 DPC_EXT class that is possible.

Go to SE24 and specify DPC_EXT class name and click on Copy Class/Interface

Select entity set and double click on it

In version 1. I had fetched up to 10 rows only and now in our version 2 I had just modified code

With a small change fetching up to 20 rows.

Same as above we need to maintain our service and now, we will be able to see two versions.

Select the service and click on SAP Gateway Client.

Now we can observe our URI with V=2 as below

Click on Execute by selecting URI Option $ count in V=2 and processed records are 20

Structural changes in ODATA SEGW

SEGW -> PROJECT 1 ----> Technical Model Name1

SEGW -> PROJECT 2 ----> Technical Model Name2

Suppose there is a structure change in initial version has 4 fields and version 2 has 3 fields only according to requirement.

If we copy project 1 to project 2 also with separate model names will be generated also still, we Should keep technical service name same to ensure consistency.

Go to SEGW Select the Project and click on copy project

A new project will be copied from original source project.

Sample requirement previous Entity type we had 4 fields no we need to keep only 3 select the field and click on remove

Once field is removed click on save.

Click on Generate Project

Always Technical service name should be same as Initial Version 1and we need to mention version number as well.

Check Runtime Artifacts all are copied by default all will be copied just a cross-check would be helpful sometimes.

Select the DPC_EXT and click on it

Select the method and go to the required entity set and redefine the method.

Best Practices: When copying a project or making changes to the entity structure, ensure that custom methods are redefined again.

In the custom method I am adding same code with slight modification over fetching

Same as above we need to maintain our service and now, we will be able to see two versions.

Select the service and click on SAP Gateway Client.

Now we can observe our URI with V=3 as below

Click on Execute by selecting URI Option $ count in V=3 and processed records are 30.

This versioning method allows you to manage changes efficiently, ensuring compatibility and facilitating independent development between teams.

For more details, please follow the below development topic pages

ABAP Development | SAP Community

OData - SAP Community

NW ABAP Gateway (OData) - SAP Community

Questions, comments, or further details required? Use the Comments section below.

Follow my profile Abhilash Daggubati for similar blog posts.

Thanks All

How to enhance system generated ODATA service in SAP BW4HANA

2024-11-22T10:45:03.656000+01:00

Overview: This blog will guide you through the steps to enhance the system generated OData service In BW4HANA.

Prerequisites:

SAP BW4HANA - SAP BW Query
SAP BW4HANA – OData Services

In BW4HANA Odata service can be generated automatically from BW query by clicking checkbox “By Odata”, this service is then can be activated in any SAP Gateway system and consumed from there.

In case of any requirements to enhance the system generated service below steps can be followed.

Steps:

Step 1: Generate OData service from BW Query.

Step 2: Create a project in t-code SEGW. Please remember <Project Name>_SRV is going to be the new service name, so please name the project accordingly.

Step 3: Right click on the Data Model and click on “Redefine” -> “OData Service (SAP GW)

Step 4: In this screen it will ask for a service where we need to select the system generated service that needs to be enhanced and click “Next”

Step 5: Click Select all and click on Finish

Step 6: Enhance the Result set with new field and Save.

Step 7: Right click on project and click on “Generate Runtime”

Runtime artifacts will be generated like shown below

Step 8: Go to DPC_EXT (Data provider extended class)

Select GET_ENTITYSET method and click on Redefine button

Step 9: Write the logic to populate the newly added field here. Super class get_entityset code will be shown by default, start the new logic after the default code. Please note that this code will be executed for each and every row in output.

Step 10: Test the output of OData service.

Go to TCODE /IWFND/GW_CLIENT, give the URL in Request URI and click on execute.

Validate the output with written logic.

Steps to Replace OData in Business Application Studio UI5 Extension Project

2024-12-02T17:35:04.959000+01:00

How to change OData service when using BAS Extension Project for Standard Apps

Background: Sometimes, standard FIORI apps cannot be extended via BAS Adaptation Project. This limitation arises if the app contains synchronous views. In such cases, you may need an alternative approach to customize the app effectively.

Requirement: The standard app ‘Transfer Stock - Cross-Plant’, includes buttons to transfer stock between plants. My requirement is to customize the app to grey out the buttons based on the plant category.

Solution:

This standard app uses OData service MMIM_MATERIAL_DATA_SRV. To implement the required changes, I created a custom OData service ZMMIM_MATERIAL_DATA_SRV, based on the standard service with an additional field. While the creation of this service is beyond the scope of this blog, I will focus on integrating it into the app.

The buttons I customized are highlighted in the below image.

Image source: https://fioriappslibrary.hana.ondemand.com/sap/fix/externalViewer/#/detail/Apps('F1957')/S21OP

Steps to Implement the Customization

1. Start by opening the BAS tool and selecting the Adaptation Project option.

2. Fill in the necessary details for the project setup and proceed to the next step.

3. Select the relevant system associated with the project.

4. Upon choosing the standard app, a message will appear indicating that the app contains synchronous views.

5. Due to the limitation, you cannot proceed with an Adaptation Project. Instead, create an Extension Project and click Finish.

6. Once the Extension Project is created, open it separately (optional). Then, create an extension by right-clicking the .extconfig.json file.

7. In the context menu, choose ‘Extend Controller’ and then select ‘Copy of the Original Controller’.

8. Uncomment the function ‘_loadMaterial’ in the file ‘S1Custom.controller.js’. This is where the oData service needs to be replaced.

9. Replace references to the standard OData service with the custom OData service ZMMIM_MATERIAL_DATA_SRV in your UI5 extension project. The required changes are shown below:

10. Search for all occurrences of the model ‘oMaterialData’ in the code. Update them accordingly to use the custom service.

11. In the custom OData service, I added a new property ‘PlantCategory’ to the existing entity type ‘MaterialPlant’.

12. Update the UI5 code to use new property ‘PlantCategory’ in the function ‘_checkFirstClickIsAllowed’. This ensures the buttons are always greyed out based on the plant category.

Testing:

Before the change (in the standard app):

After the change (in the enhanced app):

As it can be seen from the above output, the buttons in the entire row are disabled. Requirement has been achieved.

New AWS option for SAP ODP data extraction through AWS Glue

2024-12-13T09:34:58.207000+01:00

In November 2024, AWS updated its guidance for SAP Data Extraction with a Glue connector.

This adds to the previous guidance using Amazon AppFlow service. But when to use what? lets dive in

Amazon Appflow Approach

AppFlow is the AWS pre-configured integration service, if you are familiar with SAP Integration Suite, Fivetran, Airbyte or similars, you already know the drill. One tool to connect all, highly transactional, easy to configure.

AppFlow has a pre-configured SAP OData Connector, so we don't need to build it. Since its launch, it has been super easy to set up a data flow from SAP to AWS in just a few clicks, great for prototyping and relative small data sets replication.

AppFlow makes it simple, in 4 steps you define the flow, you prepare the data, add transformations, partitioning and aggregation if necessary and in a few clicks you have your raw data on AWS.

Integration is quite flexible in a low-code no-code fashion and allows modern file formats, the next step, depending of the case, would be to curate the data, with services like Glue.

New AWS Glue Approach

Now, AWS has introduced an AWS Glue OData connector for SAP, contrary to an Integration service, Glue provides a serverless data processing (ETL) service. It's based on Spark.

Glue is more suitable for extensive data integration as well as distributed data processing capabilities, complex transformations, and analytics.

So this week, AWS announced the Odata Connector on Glue. Great because we dont need to learn Scala to build our own connector.

AWS provides more than 40 predefined connectors, plus hundreds of more connectors available through the AWS Marketplace. Glue capabilities are immense, they not only provide extensive ETL capabilities, but most importantly, they store the Data Catalog, a critical feature for search and query using Amazon Athena or Amazon Redshift.

AWS Glue ETL Workflow. Courtesy of AWS

For entire details of the new Glue connector to SAP, read this blog;

https://aws.amazon.com/blogs/big-data/scaling-rise-with-sap-data-and-aws-glue/

Key Differences and when to use

Literature

https://docs.aws.amazon.com/glue/latest/dg/connecting-to-data-sap-odata.html

https://aws.amazon.com/blogs/big-data/scaling-rise-with-sap-data-and-aws-glue/

Enable OData Streams in RAP

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

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

Solution:

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

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

ABAP Conference recording: Enable OData Streams in RAP

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

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

Use cases covered:

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

Code based GitHub URL's:

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

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

CREATE_DEEP_ENTITY using RAP ( Unmanaged )

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

Hello Experts,

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

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

Step 1 : Parent CDS :

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

Step 2 : Child CDS :

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

Step 3 : Unmanaged Behavior Definition :

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

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

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

Step 4 : using quick fix create the implementation Class

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

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

CLASS lhc__order DEFINITION INHERITING FROM cl_abap_behavior_handler.
  PRIVATE SECTION.

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

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

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

    METHODS update FOR MODIFY
      IMPORTING entities FOR UPDATE _order.

    METHODS delete FOR MODIFY
      IMPORTING keys FOR DELETE _order.

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

    METHODS lock FOR LOCK
      IMPORTING keys FOR LOCK _order.

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

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

ENDCLASS.

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

METHOD deep_create.

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

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

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

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


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

          ENDLOOP.


        ENDLOOP.
  ENDMETHOD.

Finally we create the service binding and service definition

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

then we move to testing

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

Retrieve Data from Rest API to ABAP

2025-05-27T09:27:13.029000+02:00

Introduction

In abap, we create and expose API service through the OData gateway client for integration with third-party systems. This blog focuses on how to retrieve data from a REST API using a standard ABAP class. I have created the OData service using the GET_ENTITY method in an OData project and consumed that API using the approach described below.

cl_http_client
if_http_client

****Data Declarations****
TYPES: BEGIN OF tt_json,
         MaterialCode TYPE matnr,           "Material
         UserName     TYPE ernam,           "Creator Name
         mtart        TYPE mtart,           "Material Type
       END OF tt_json.

TYPES: BEGIN OF ty_field,
         fielname TYPE char40,              "Field Name
       END OF ty_field.

DATA: lt_material     TYPE TABLE OF tt_json,
      lt_tab          TYPE TABLE OF ty_field,
      ls_material     TYPE tt_json,
      lo_http         TYPE REF TO if_http_client,    "HTTP Client Abstraction
      lr_data         TYPE REF TO data,
      lv_result       TYPE string,
      lv_content_type TYPE string,
      lv_action_type  TYPE string.

FIELD-SYMBOLS: <ls_data>   TYPE data,
               <ls_d>      TYPE data,
               <ls_struct> TYPE data,
               <lv_any>    TYPE any,
               <lv_char>.

SELECTION-SCREEN BEGIN OF BLOCK a1 WITH FRAME TITLE TEXT-002.
  PARAMETERS: p_mat TYPE matnr OBLIGATORY.
SELECTION-SCREEN END OF BLOCK a1.

*Get URL
DATA(lv_url) =  |{ TEXT-001 }'{ p_mat }')|  .

The API and selection screen look likes,

"To perform the HTTP communication using factory method.
cl_http_client=>create_by_url(
  EXPORTING
    url                    = lv_url           " URL
  IMPORTING
    client                 = lo_http          " HTTP Client Abstraction
  EXCEPTIONS
    argument_not_found     = 1                " Communication parameter (host or service) not available
    plugin_not_active      = 2                " HTTP/HTTPS communication not available
    internal_error         = 3                " Internal error (e.g. name too long)
    OTHERS                 = 7
).
"
IF sy-subrc = 0.
  lv_content_type  = 'application/json'.
  lv_action_type   = 'GET'.
  lo_http->request->set_content_type(  lv_content_type ).
  lo_http->request->set_method( lv_action_type ).
"The output shows a json format.
  lo_http->request->set_header_field(
  EXPORTING
    name  =  'Accept'                          " Name of the header field
    value =  'application/json'                " HTTP header field value
).
"To ignore the authentication during execution.
  lo_http->propertytype_logon_popup = if_http_client=>co_disabled.
  lo_http->authenticate(
  EXPORTING
    proxy_authentication = ' '            " Proxy Logon (= 'X')
    client               = '800'          " R/3 system (client number from logon)
    username             = 'username'     " ABAP System, User Logon Name
    password             = 'password'     " Logon ID
    language             = 'E'            " SAP System, Current Language
).
ENDIF.

lo_http->send(
  EXPORTING
    timeout                    = 15                 " Timeout of Answer Waiting Time
  EXCEPTIONS
    http_communication_failure = 1                  " Communication Error
    http_invalid_state         = 2                  " Invalid state
    http_processing_failed     = 3                  " Error when processing method
    http_invalid_timeout       = 4                  " Invalid Time Entry
    OTHERS                     = 5
).
IF sy-subrc <> 0.
* MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
*   WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.

lo_http->receive(
  EXCEPTIONS
    http_communication_failure = 1                " Communication Error
    http_invalid_state         = 2                " Invalid state
    http_processing_failed     = 3                " Error when processing method
    OTHERS                     = 4
).
IF sy-subrc <> 0.
* MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
*   WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
ENDIF.

*Get the response from target as character string cdata( ).
lv_result = lo_http->response->get_cdata( ).
lo_http->close( ).

We have the response from target system and need to retrieve the data from the string variable lv_result.

*Deserialize the data from Json to Abap
/ui2/cl_json=>deserialize(
  EXPORTING
    json             =  lv_result         " JSON string
  CHANGING
    data             =  lr_data           " Data to serialize
).

lt_tab =  VALUE #( ( fielname = 'MATERIALCODE')
                   ( fielname = 'USERNAME')
                   ( fielname = 'MTART'  ) ).

ASSIGN lr_data->* TO <ls_data>.
ASSIGN COMPONENT 'd' OF STRUCTURE <ls_data> TO <ls_d>.

DATA(lo_typedescr) = cl_abap_typedescr=>describe_by_data( <ls_d> ).
ASSIGN <ls_d>->* TO <ls_struct>.
IF <ls_struct> IS ASSIGNED.
  LOOP AT lt_tab INTO DATA(ls_tab).
    ASSIGN COMPONENT ls_tab-fielname OF STRUCTURE <ls_struct> TO <lv_any>.
    IF <lv_any> IS ASSIGNED.
      ASSIGN <lv_any>->* TO <lv_char>.
      IF <lv_char> IS ASSIGNED.
        ASSIGN COMPONENT ls_tab-fielname OF STRUCTURE ls_material TO FIELD-SYMBOL(<lv_target>).
        IF <lv_target> IS ASSIGNED.
          <lv_target> = <lv_char>.
        ENDIF.
      ENDIF.
    ENDIF.
  ENDLOOP.
ENDIF.
UNASSIGN: <ls_data>,<ls_d>,<ls_struct>,<lv_any>,<lv_char>,<lv_target>.

cl_demo_output=>begin_section( 'Material Detail' ).
cl_demo_output=>write_data( ls_material ).
cl_demo_output=>next_section( 'OData Service URL' ).
cl_demo_output=>write_text( lv_url ).
cl_demo_output=>display( ).
CLEAR: ls_material.

The output should be like below in debugger level.

Test the above service URI to postman app in GET method.

Note: In the example above, I retrieved data from an OData HTTP API that does not require an SSL certificate. However, when communication with external APIs. an SSL certificate is typically required. We will cover this in detail in a separate blog post.

Thank you!

Implementing BOPF Actions Using CDS-Based Business Objects in S/4HANA

2025-06-24T09:40:16.716000+02:00

Introduction

In SAP S/4HANA, Core Data Services (CDS) are widely used to define meaningful and reusable data models. When these CDS views are annotated correctly, they can automatically create a Business Object Processing Framework (BOPF) model. This helps in building business objects faster and with less manual effort.

In real-world applications, we often need to perform actions that go beyond just creating, reading, updating, or deleting data. For example, we might need to "Active Status" the status of a record, "Cancel" a request. These kinds of operations are called actions in BOPF.

This object explains how to add such custom actions to a CDS-based BOPF model. It helps developers extend standard functionality by including business-specific logic that users can trigger when needed.

Steps for implementing Action for the CDS-Based Business Objects.

Enhancing CDS-Based BOPF Objects with Custom Actions in S/4HANA.

Defining and Implementing Actions in BOPF via CDS Views.

@AbapCatalog.sqlViewName: 'ZCFMEAL_SQL' 
@AbapCatalog.compiler.compareFilter: true 
@AccessControl.authorizationCheck: #NOT_REQUIRED 
@EndUserText.label: 'Flight Meal Application, Consumption View' 
@OData.publish: true 
@Metadata.allowExtensions: true 
@ObjectModel:{ 
modelCategory: #BUSINESS_OBJECT, 
compositionRoot: true, 
transactionalProcessingEnabled: true, 
createEnabled: true, 
updateEnabled: true, 
deleteEnabled: true, 
writeActivePersistence: 'ZAP_FLIGHT_MEAL' 
}
 
define view ZCFMEAL 
as select from zap_flight_meal 
association [1] to scarr as _Airline on $projection.carrid = _Airline.carrid 
association [1] to sflight as _FlightInfo on $projection.carrid = _FlightInfo.carrid 
and $projection.connid = _FlightInfo.connid 
association [1] to smeal as _Meals on $projection.carrid = _Meals.carrid 
and $projection.meal = _Meals.mealnumber 
{ 
@UI.facet: [{ 
purpose: #STANDARD, 
label: 'Meals', 
type: #IDENTIFICATION_REFERENCE, 
position: 10 
}] 
@UI.lineItem: [{ position: 10, label: 'Meal ID' }, 
{ position: 10, type: #FOR_ACTION, dataAction: 'BOPF:SET_STATUS', label: 'Active Status' } 
] 
@UI.identification: [{ position: 10, label: 'Meal ID' }] 
key meal_id, 
@UI.lineItem: [{ position: 20, label: 'Carrier' }] 
@UI.identification: [{ position: 20, label: 'Carrier' }] 
@ObjectModel.foreignKey.association: '_Airline' 
carrid, 
@UI.lineItem: [{ position: 30, label: 'Connection' }] 
@UI.identification: [{ position: 30, label: 'Connection' }] 
@ObjectModel.foreignKey.association: '_FlightInfo' 
connid, 
@UI.lineItem: [{ position: 40, label: 'Meal' }] 
@UI.identification: [{ position: 40, label: 'Meal' }] 
@ObjectModel.foreignKey.association: '_Meals' 
meal, 
@UI.lineItem: [{ position: 50, label: 'Total seats' }] 
@UI.identification: [{ position: 50, label: 'Total seats' }] 
total_seats, 
@UI.lineItem: [{ position: 10, label: 'Status' }] 
@UI.identification: [{ position: 10, label: 'Status' }] 
status, 
_Airline, 
_FlightInfo, 
_Meals  

}

Once the CDS view is activated, the corresponding BOPF object is automatically generated. You can view it using transaction code BOBX and proceed to define the action.

Next, implement the business logic for the action in the corresponding BOPF action class.

The action implementation class inherits predefined methods from the BOPF framework, such as EXECUTE_ACTION.

Implementation:

Activate and generate the BOPF object.

Now add the service and utilize it in the front-end.

Add the service by Selecting and provide the package name.

You'll get an information that the metadata has been loaded for that service.

Test the service.

Now by using the Odata service create the basic Fiori application

Steps to create basic Fiori application:

Use any tool for creating Fiori like VS Code or SAP Business Application Studio (BAS).

Open Application generator-> select the template -> provide the service ->select the entity-> finish and run the application

Once the application has been generated, you can see that an action button will appear in the Fiori front-end application.

Result:

As all the status are in ‘NO’ once we select the record and click on that action the records get updated as shown below.

Conclusion:

Implementing BOPF actions via CDS views in S/4HANA demonstrates the power of combining declarative modeling with robust transactional logic. By leveraging CDS annotations and standard frameworks, developers can deliver efficient, user-friendly, and scalable business applications—reducing custom code while staying aligned with SAP’s clean core principles.

I Skipped Fiori (And I'd Do It Again)

2025-06-26T23:31:10.570000+02:00

Or: How TRIZ Taught Me The Best UI Is No UI

Hey SAP folks! 👋

Deep breath.

I have a confession: I skipped Fiori. Just like I skipped SAP Smart Forms (jumping straight from SAPscript to Adobe Forms) and WebDynpro (leaping from SAPGUI to Fiori). Before you assume I'm just another anti-Fiori rebel, hear me out.

I loved Fiori when it launched in 2013. Finally, SAP that didn't look like Windows 95! Responsive design! Tiles! But it's 2025, and we're still... clicking... through... tiles... to... do... everything.

After working with Fiori since 2015, I had an epiphany that would make any TRIZ (innovation theory) person weep with joy:

"The ideal system is one that doesn't exist but its function is performed."

The "This Can't Be The Future" Moment

Picture this: 9 AM Monday. CFO pings you: "Need the latest P&L for company 1000 — compare this quarter to last, right now."

The Fiori Way™:

Open Fiori Launchpad (wait for tiles to load)
Find "Financial Statement Analysis" app
Click tile (wait for app to load)
Select company code from dropdown
Choose fiscal period and year
Apply profit center filters
Navigate through multiple screens
Export to Excel for actual analysis

Time: ~4 minutes · 23 clicks · 8 screens · Frustration: Daily

The 2025 Way:

Me: Show me P&L breakdown for company code 1000, 
    this quarter vs last quarter

Claude: Q4 2024 vs Q3 2024 analysis ready:
        Revenue: +12% ($2.4M → $2.7M)
        EBITDA margin improved 3.2% 
        (cost optimization in logistics)
        Key driver: 18% increase in Product Line A

Time: 8 seconds · Clicks: 0 · Sanity: Preserved

How I Built The Bridge to Skip Ahead

I knew exactly what I wanted to track. After years with Fiori, I understood the game. So I built a Chrome extension that captures:

Every click, input, form submission
Every OData request triggered by those clicks
Complete UI5 context and metadata
Atomic action decomposition with parametrization

The pattern was always there:

User Action → UI Update → OData Call → Backend Logic

The TRIZ insight: Why do we need the first two steps at all?

OData Call → Backend Logic

(Whisper: MCP - OData Bridge!)

The Shocking Truth: 80% Pure Waste

My extension analysed hundreds of Fiori sessions across different apps. The results?

Real data from "Manage Detection Methods":

Duration: 27.7 seconds
Clicks: 10
OData requests: 15
@uiannotations involved: 23
Actual business logic: Update one field

Pattern discovery:

UI Layer: 80% overhead (pure translation)
Business Logic: 20% actual work
Innovation opportunity: Eliminate the 80%

Liberation from @ui Annotation Hell

Remember wrestling with cryptic @ui annotations? Hours spent debugging why fields don't appear, fighting responsive design, calling consultants when layouts break.

When you eliminate the UI, you eliminate the entire annotation ecosystem. Clean CDS views with pure business logic. No more @ui.* black magic.

The Three Pillars That Let Me Skip Fiori

Parametrized Automation→ Record once, replay forever with different parameters
Intelligent Test Generation → Describe in English, auto-generate reliable tests
AI-Ready Business Tools → Convert interactions to semantic tools Claude understands

The Transformation Results

95% time reduction. 100% complexity elimination.

The "But What About..." Section

"But what about data visualization?" Great question! Complex charts and graphs? Keep those Fiori apps. But for the 80% of interactions that are just CRUD operations? Dead.

"But what about user permissions?" The OData services already handle that. If you can't do something in Fiori, the AI can't do it either. Security preserved, clicking eliminated.

"But what about complex workflows?" You mean like "Create PO → Route for approval → Update inventory"? Watch this:

"But what about mobile?" You know what works great on mobile? Chat. You know what doesn't? Trying to click tiny Fiori tiles on a phone screen.

What This Means For You

For Functional Consultants: Demonstrate a process once, get automation forever. No coding required.
For Developers: Focus on business logic. Let AI handle the interaction layer.
For Managers: Measure ROI in seconds saved × transactions per day. The math is beautiful.
For Everyone: The future isn't better UIs — it's no UIs at all.

Your Turn

Ready to skip your own Fiori apps? The extension turns any SAP professional into an automation architect.

What's your most time-wasting Fiori workflow? Comment below with your biggest pain point — I'll analyse the potential time savings and show you the elimination path.

The ideal interface is one that doesn't exist but gets the job done.

Time to evolve beyond clicking. 🚀

Technical deep-dive and extension demo ➜ [Coming Soon] Next week: "How TRIZ Principle 13 Made SAP Read My Mind"

Quick Reference/Glossary: see in comments.

Let me know in comments what you want me to eliminate next 😃

API to Delete GOS Attachment from Transaction Code & their Applications

2025-08-11T12:26:01.244000+02:00

Summary

This technical blog is subject to simplify process of attachment deletion and how best way it can be applicable to act as an API.

Introduction

We have come across multiple technical blogs on attachment( can be PDF, image or MS Office objects) in the specific T-Code of the Transactions, such as for Sales Order, Billing Invoice or other relevant business transactions.

Here we will focus on the business requirement to delete an already enclosed/attached one of the attachment in the Inspection Lot(QA03) Transaction and methods of implementations.

The solution is bifurcated in the simple 3 steps and we will use a simple and straight standard class (CL_GOS_DOCUMENT_SERVICE) which will be generic to use for other transactions as well.

Step 1. Pass Object Types Object Key along with Doc ID
Step 2: Call DELETE_ATTACHMENT method of CL_GOS_DOCUMENT_SERVICE Class
Step 3: Commit and wait.
Code Snippet will give a complete solution
***************************************************************************************************
** Work area declare

  DATA: LS_LPORB    TYPE SIBFLPORB,
        LS_LINK     TYPE OBL_S_LINK. 

DATA: LO_REF TYPE REF TO CL_GOS_DOCUMENT_SERVICE.

************************* Step 1 ***************************************

** Value assignment

    LS_LPORB-INSTID = <Key Field> . "Pass Key field, in this case it can be Inspection Lot Number
    LS_LPORB-TYPEID = <Business Object>. "For Example 'BUS2045'Business Object of Inspection Lot
    LS_LPORB-CATID  = <Object Type>. " For Example'BO' Object Type
    LS_LINK-INSTID_B = <Doc ID>. “Pass Doc ID here

*********************** Step 2 *************************************

** Calling Standard Class

CREATE OBJECT LO_REF.

  CALL METHOD LO_REF->DELETE_ATTACHMENT
    EXPORTING
      IS_LPORB      = IS_LPORB
      IP_ATTACHMENT = IS_LINK-INSTID_B.

*************************** Step 3 ******************************

  COMMIT WORK AND WAIT.

***************************************************************************************************

Application

Above Snippet can be fix in the below box, shows a simple Application approach interface with UI/BTP or any Non-SAP application sending request via any Interface or middle layer can be Odata service using SAP gateway using Client-Server response methodology.

Simple above code snippet can be placed as part of API logic which will perform its deletion operation in the SAP Transactions such as Inspection Lot/Sales Order/Billing Invoice.

Conclusion

Deletion of attached document can be deleted by using simple standard class.

Will come up with another series technical developments around Inspection Lot.

Pagination concept in OData - ECC for SP - 7.3

2025-08-12T08:07:32.133000+02:00

Summary

This technical blog will open option to include pagination concept in Odata Service running on ECC system.

Introduction

This article is specific for developer who are still developing Odata Services on ECC on Pagination Concept.

There are multiple blogs available on Pagination on S4 system but eventually same concept or logical approach is challenging while working in the ECC system.

How pagination works in S4 HANA system

Will talk on the existing solutioning part on S4 end before we come to ECC.

There are two keywords being used to restrict the count - one is $top and the other is $skip. Both of the them play roles to restrict the count. I will not go in details about their operations as there are already existing blogs on it.

In S4, above keywords are used in the follows syntax to perform Pagination.

SELECT <field1>,

<field2>,

... ,

FROM <SAP DB table>

ORDER by <Key_field>

INTO TABLE @<internal_table>

OFFSET @paging-skip UP TO @paging-top ROWS.

Challenge in ECC system

But when it comes to ECC, above syntax difficult to apply directly as SKIP & ROWS are being used with OFFSET and UPTO keywords, which are not applicable for SAP-ECC system.

Solution

But, there are other approaches to handle paging in ECC. Here instead of restricting at the time of data fetch using SELECT query, will narrate how paging can be used using SAP standard class.

Below steps to follow to implement pagination in ECC system.

1. Pull TOP & SKIP from IO_TECH_REQUEST_CONTEXT into work area.

2. Use PAGING Method of SAP Utility Class - /IWBEP/CL_MGW_DATA_UTIL.

3. Pass work area with TOP & SKIP in PAGING method.

Working Code is below

******************Data Declaration ***************************

DATA: WA_PAGING TYPE /IWBEP/S_MGW_PAGING.

******************Assign Top & Bottom***********************

WA_PAGING-TOP = IO_TECH_REQUEST_CONTEXT->GET_TOP( ).
WA_PAGING-SKIP = IO_TECH_REQUEST_CONTEXT->GET_SKIP( ).

****************Call Data Utility Class*************************
CALL METHOD /IWBEP/CL_MGW_DATA_UTIL=>PAGING
EXPORTING
IS_PAGING = WA_PAGING
CHANGING
CT_DATA = <ENTITY_SET>. "This table can be EntitySet of Odata Service

Conclusion

CT_DATA will have only specific number of counts (Skip & Top) as specified in the URI.

Enabling Background Job Execution in S/4HANA from Fiori Using CDS and OData

2025-08-21T08:04:03.004000+02:00

Business Scenario

Imagine a purchasing department needing to update material prices based on market conditions. Instead of manually running a report in background mode, users can select materials in a Fiori app and click “Update Prices”, which triggers a background job with selected data.

Component Purpose

CDS View	For showing material list in Fiori
OData Function Import	Triggers a background job
Fiori App	Allows selection + button click
ABAP Report	Executes price update logic
SM37	Monitor the job execution

Step-by-Step Implementation

Step 1: CDS View for Material Selection

This will expose a simple material list for selection.

Step 2: Create SEGW Project and Import CDS View

T-code: SEGW

Create project: Z_MATERIAL_JOB_API

Import CDS view as Entity Type

Generate runtime artifacts

Step 3: Add Function Import to SEGW

In SEGW:

Right-click Data Model → Function Imports → Create
Name: TRIGGER_PRICE_JOB
Return Type: None
HTTP Method: POST

2. In Modeling, assign an Entity Set if needed (optional).

Step 4: Implement Function Import Logic

In class: ZCL_Z_MATERIAL_JOB_API_DPC_EXT

method /iwbep/if_mgw_appl_srv_runtime~execute_action. 
 
  data: lv_jobname type tbtcjob value 'ZPRICE_UPDATE_JOB', 
        lv_jobcount type tbtco-jobcount, 
        lv_msg type string, 
        lt_materials type standard table of mara-matnr. 
 
  if iv_action_name = 'TRIGGER_PRICE_JOB'. 
 
    " (Optional) collect materials from CDS selection or payload 
    append 'MATERIAL1' to lt_materials. 
    append 'MATERIAL2' to lt_materials. 
 
    " Submit the job 
    call function 'JOB_OPEN' 
      exporting 
        jobname          = lv_jobname 
      importing 
        jobcount         = lv_jobcount 
      exceptions 
        others           = 1. 
 
    if sy-subrc = 0. 
      " Submit custom report in background 
      submit zmat_price_update_report 
        with so_matnr in lt_materials 
        user sy-uname 
        via job lv_jobname 
        number lv_jobcount 
        and return. 
 
      call function 'JOB_CLOSE' 
        exporting 
          jobname     = lv_jobname 
          jobcount    = lv_jobcount 
          strtimmed   = 'X' 
        exceptions 
          others      = 1. 
 
      lv_msg = |Job { lv_jobname } triggered successfully.|. 
 
    else. 
      lv_msg = 'Job could not be started.'. 
    endif. 
 
    " Send response back to OData 
    data: lr_return type ref to /iwbep/if_message_container. 
    lr_return = me->get_message_container( ). 
    lr_return->add_message( 
      exporting 
        iv_msg_text   = lv_msg 
        iv_msg_type   = /iwbep/if_message_container=>gcs_msg_type-success 
    ). 
 
  endif. 
 
endmethod.

Step 5: Background Report ZMAT_PRICE_UPDATE_REPORT

REPORT zmat_price_update_report. 
 
PARAMETERS: so_matnr TYPE mara-matnr RANGE. 
 
START-OF-SELECTION.	 
 
  LOOP AT so_matnr INTO DATA(lr). 
    " Dummy logic - Simulate price update 
    WRITE: / 'Updating price for material:', lr-low. 
  ENDLOOP.

Output – What Happens in Fiori

User opens the Fiori app showing materials from CDS.
Selects a few materials → clicks “Update Prices”.
The TRIGGER_PRICE_JOB function import is called.
SAP triggers a job: ZPRICE_UPDATE_JOB
The custom report runs in background → check SM37

Log:

Conclusion:

This approach bridges Modern UI and robust backend logic. You can now let Fiori apps initiate background-heavy tasks — like price updates, data migration, or batch jobs — with traceable and efficient execution.

SITLON 2025 - Segurança em Aplicações/Serviços no BTP em épocas de IA, e toda sua história/evolução!

2025-08-26T22:48:18.118000+02:00

Hello World! Tudo bem?

Após o encerramento com sucesso do primeiro SAP Inside Track Londrina (2025), que foi um evento somente presencial e contou com muitas apresentações de qualidade, resolvi criar esse material aqui na comunidade para aqueles que não puderam comparecer pessoalmente.

Então segue a apresentação do conteúdo do SIT Londrina 2025, em formato "Live":

Mas se ainda não se contextualizou, sugiro antes de assistir o material acima ler todo o conteúdo abaixo e entender a evolução até o evento SIT Londrina 2025, ok?

Se você não conhece SAP e chegou até aqui, segue um pequeno resumo:

SAP é um software de gestão empresarial usado pelas maiores e mais importantes empresas do mundo para integrar e otimizar processos de negócios cruciais, como finanças e logística. Ele centraliza dados para fornecer uma visão completa e em tempo real, permitindo decisões estratégicas mais rápidas e eficientes. A sua importância reside em ser uma espinha dorsal tecnológica que garante a eficiência e a competitividade global dessas corporações.

No evento, realizei a apresentação “Segurança em Aplicações/Serviços no BTP em épocas de IA” sobre Cyber Security no mundo SAP, para aplicações desenvolvidas em um modelo bem específico. Mas com esse post aqui, o objetivo é atingir e disponibilizar o conteúdo a todos da comunidade SAP, bem como os curiosos e interessados pelo tema de segurança da informação. Como muitos podem estar lendo pela primeira vez sobre o tema e o que eu já fiz até então, vou detalhar a historia desde o começo de uma maneira resumida até chegar no SIT Londrina 2025, ok?

Tudo começou na Pandemia, no ano de 2020/2021, onde estava fazendo uma pesquisa para um blog que iria escrever sobre um tutorial de um tipo desenvolvimento Web especifico (SAPUI5) . Esse tutorial seria sobre o desenvolvimento de aplicações UI5/FIORI ao publico B2C, ou seja usuários que em sua maioria nunca teriam visto nada sobre SAP e que para eles seria como uma aplicação Web qualquer, também aplicações essas que seriam disponibilizadas na internet para acesso do publico em geral. No Blog eu iria abordar a arquitetura recomendada, exemplos de códigos fonte, etc., porém na etapa de pesquisa para apresentar alguns “exemplos” já existentes no mercado, me deparei com cenários muito assustadores!

Para contextualizar, “o sistema SAP” sempre é em sua maioria um sistema “fechado”, onde o acesso é feito geralmente por quem de fato precisa do mesmo (até por questão de custo de licença). Analisando a minha experiencia, de colegas e muitos estudos, conseguia afirmar então que os profissionais que desenvolvem, desenham e/ou especificam soluções SAP ao “publico geral”, em sua maioria não tem uma preocupação com os quesitos de segurança. No mundo SAP, os desenvolvimentos geralmente ficam dentro do sistema e/ou na rede interna do cliente, então esse tópico nunca foi muito explorado pelos profissionais e consultorias que desenvolvem soluções customizadas, e esse aqui foi o principal motivador de iniciar todo o conteúdo. Ou seja, profissionais do mundo SAP precisam se atentar e se preparar ao criar soluções desse tipo, pois os impactos de não fazer algo correto podem ser enormes (que verá logo mais alguns exemplos). Pois se algum desses casos caísse nas mãos erradas, não só a imagem da empresa em questão que usa SAP, independente do país que está localizada, seria impactada com prejuízos financeiros e até implicações legais, mas nós profissionais do mundo SAP também seriamos impactados pela “imagem” que seria passada que o sistema SAP é de alguma maneira "inseguro".

Antes de entrarmos no detalhe tenho que falar algo importante, tudo que falarei daqui em diante diz respeito a aplicações/serviços customizados e não standard SAP, ou seja foram soluções desenvolvidas por alguém para atender o requisito daquele cliente em específico, e não algo que “vem” no produto SAP. Soluções SAP a nível de produto no geral são muitos seguras, onde a mesma investe muito para manter o mais alto nível de segurança, utilizando todas as ferramentas e métodos de mercado para tal. Até ter programas onde pode “contratar” profissionais de cyber segurança para tentar explorar e descobrir como deixar seus produtos mais seguros (onde eu posso ou não ter participado. NDA). Recomendo os links 1 e 2 para quem deseja se aprofundar mais no tema de segurança no nível de produto SAP. Outro ponto importante, é que demonstro como essas aplicações customizadas podem ser facilmente encontradas na internet por ferramentas como Google Buscador.

Na pesquisa fui encontrando muitas empresas vulneráveis em um numero altíssimo, quase podendo afirmar que mais 30% das que encontrei, tinham algum problema. Então o que era um tutorial mudou para uma pesquisa mais aprofundada do tema, e com isso resolvi criar o movimento #SafeSAPUI5. Que basicamente iniciaria com a criação de material e conscientização dos profissionais para termos aplicações e serviços SAP seguros que estão expostos na internet. Pois aqui entra um detalhe técnico bem agravante, para muitos casos o requerimento do cliente (ou seja, o que ele precisa) é ter uma aplicação customizada porem sem ter a necessidade de nenhum tipo de autenticação por parte do usuário que vai acessar. Ou seja, ao clicar na URL ele já deve entrar na aplicação customizada e poder fazer a ação necessária, cenário esse que foge bem do “padrão” SAP e existem muitas e muitas aplicações como essa espalhadas pelo mundo.

Os materiais do #SafeSAPUI5 podem ser encontrados aqui.

Além dos mesmos, como já estava pronto para escrever, resolvi criar um Ebook gratuito sobre o tema, juntando um pouco de historia, exemplos, dicas e casos reais. Com isso, nasceu o ebook UI5 Hacker, que pode ser encontrado gratuitamente aqui (Português e Inglês).

Juntando tudo isso apresentei a primeira palestra do tema, ainda na Pandemia, no evento UI5 Con 2021 (em Inglês) que é a conferencia global de SAPUI5, biblioteca utilizada para realizar esses desenvolvimentos (mais detalhes na palestra ou ebook).

UI5CON 2021: #SafeSAPUI5:

Depois da mesma, com a ajuda da própria SAP, consegui espalhar essa conscientização e também comunicar os clientes ao redor do mundo que estavam inseguros e foram citados nos exemplos da palestra e ebook (alguns com vulnerabilidades muito graves, como cópia do passaporte de todos os usuários pronta para ser extraída por exemplo). Importante, era possível conseguir isso sem precisar realizar nenhum tipo de hack, apenas saber executar um serviço/API que está exposto na internet (até pelo próprio navegador).

Então em 2023, resolvi fazer um compilado do material de 2021 em Português (com alguns novos exemplos) e apresentar no SIT SP 2023 (Serviços Seguros & Aplicações Seguras), trazendo a tona novamente o material e o tema (agora focado mais em Português).

A palestra pode ser vista no Youtube aqui:

Com isso tive muitos feedbacks positivos de profissionais e de clientes SAP que resolveram suas vulnerabilidades e passaram a adotar as praticas em seu dia a dia, para esse e outros requisitos. Mas é importante falar, é possível SIM fazer uma aplicação WEB como essa que descrevi acima de maneira segura e protegida para o seu cliente, só seguir as boas praticas e utilizar as ferramentas corretas. Acontece que nesse "meio tempo", a adoção do SAP BTP (oferta da SAP de serviços Cloud, assim como os outros grandes players de tecnologia) cresceu exponencialmente no mundo todo. Se iniciou então um movimento de muitos clientes para levarem suas soluções para o BTP (conhecido como o movimento “move to cloud”), e alguns deles com aplicações se enquadrando nas possíveis vulnerabilidades descritas.

Mas e então, apenas levar as aplicações ao BTP as deixam seguras?

E com a chegada, popularização e massiva utilização/evolução das Inteligências Artificiais (IAs) impactam nisso tudo?

Para responder as questões acima e trazer a tona novamente o tema, resolvi criar o material da palestra apresentada no SIT Londrina 2025: “Segurança em Aplicações/Serviços no BTP em épocas de IA”. Mas como comentei antes, o evento foi somente presencial e por conta disso resolvi realizar uma “live” com o mesmo material e conteúdo para disponibilizar a todos o mesmo. Colocando em uma linha do tempo então, ficaria assim:

O PDF do material apresentado no SIT Londrina 2025 pode ser encontrado aqui.

Após a apresentação desse material (PDF e "Live"), demonstro que uma simples ida ao SAP BTP com aplicações nesse modelo não te deixará mais seguro. E com a chegada das IAs, existe hoje uma rápida revolução no segmento de Cyber Security (assim como o mundo em geral) que as empresas que utilizam soluções SAP devem estar atentas e preparadas.

Espero que tenha gostado do conteúdo e lhe ajudado, e que de alguma maneira tenha agregando algo ao seu conhecimento atual.

Obrigado e nos vemos nas próximas aventuras do “Hacker do Bem”.

How to connect with SAP S/4HANA OData Services from SAP APIM?

2025-11-13T17:45:49.137000+01:00

Assuming that you have enabled the API Management capability in Integration Suite, I will start with API Provider creation.

1. Create API Provider

Connection

Type	On Premise
Host	Virtual Host, as mentioned in Cloud Connector
Port	Virtual Port, as mentioned in Cloud Connector
Location ID	As mentioned in Cloud Connector
Authentication	NONE
Additional Properties:	sap-client: XXX

Catalog Service Settings

Path Prefix	/sap/opu/odata
Service Collection URL	/IWFND/CATALOGSERVICE;v=2/ServiceCollection
Authentication type	BASIC
Username	SAP's User Name for communication
Password	***

Test connection:

2. Create API Proxy

Select the API Provider, click on Discover to select the API which you wanted to use

Select the API & then click on Create.

3. Create Key Value Map to store the credentials to S/4HANA

4. Add Policies

Verify API Key - To verify the key which you are going to pass while calling the API.
Where do you get the API? - When you create the Product, and a Subscription, after creating a Subscription in the Developer Hub you will get a Key. That key is to be provided to the Consumer, and this Policy will verify the key sent by the consumer.

 <!--Specify in the APIKey element where to look for the variable containing the api key--> 
<VerifyAPIKey async='true' continueOnError='false' enabled='true' 
xmlns='http://www.sap.com/apimgmt'>
	<APIKey ref='request.header.apikey '/>
</VerifyAPIKey>

Key Value Map Operations - To fetch the credentials saved in the Key Value Mapping

<KeyValueMapOperations mapIdentifier="SAP_S4HANA_Credentials" async="true" continueOnError="false" enabled="true" xmlns="http://www.sap.com/apimgmt">
    <Get assignTo="private.usernameFromKVM" index="1">
        <Key>
            <Parameter>Username</Parameter>
        </Key>
    </Get>
    <Get assignTo="private.passwordFromKVM" index="1">
        <Key>
            <Parameter>Password</Parameter>
        </Key>
    </Get>
    <Scope>environment</Scope>
</KeyValueMapOperations>

Basic Authentication - To pass the credentials fetched in the previous step.

<BasicAuthentication async='true' continueOnError='false' enabled='true' xmlns='http://www.sap.com/apimgmt'>
	<Operation>Encode</Operation>
	<IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
	<User ref='private.usernameFromKVM'></User>
	<Password ref='private.passwordFromKVM'></Password>
 	<AssignTo>request.header.Authorization</AssignTo>
</BasicAuthentication>

Assign Message - So you get an error as, "{"fault":{"faultstring":"Unsupported Encoding \"br\"","detail":{"errorcode":"protocol.http.UnsupportedEncoding"}}}".
BR is a data format Brotli which is often defined by backend for webpage loading and not accepted by default. And this Assign Message will help your message reach the target.

<!-- This policy can be used to create or modify the standard HTTP request and response messages -->
<AssignMessage async="false" continueOnError="false" enabled="true" xmlns='http://www.sap.com/apimgmt'>
 
	<!-- Sets a new value to the existing parameter -->
	<Set>
		<Headers>
		     <Header name="Accept-Encoding">gzip,deflate</Header>
	     </Headers> 
	</Set>
	<IgnoreUnresolvedVariables>false</IgnoreUnresolvedVariables>
	<AssignTo createNew="false" type="request"></AssignTo>
</AssignMessage>

5. Create Product & Add the API

6. Create a Subscription for the Product created

7. It's time to test!

Hands-On Guide: SAP Build + Joule Skill for Purchase Order Listing, Approval, or Modification

2025-12-22T08:09:03.721000+01:00

Introduction

In this tutorial, we will build an AI powered Purchase Order listing, modification or approval app using SAP Build and Joule. This step by step guide covers everything from OData integration to creating a working Joule Skill.

Table of Contents

In today’s SAP ecosystem, intelligent automation is an expectation, not a future goal. SAP Build allows developers to quickly create business applications without extensive coding and SAP Joule brings AI-driven intelligence to these experiences.

In this hands-on guide, I’ll walk you through the process of building a Joule skill that connects to an OData service, allowing users to list, approve, and update purchase orders directly through SAP Build. ( This guide uses ZTABLE to store purchase order data because the standard SAP tables in the test system I work on don't have enough or the right kind of data. However, you can use the standard tables instead of ZTABLE. )

This project shows how AI capabilities can seamlessly integrate into SAP’s low-code environment, enabling automation and human decision-making in one interface. Whether you want to enhance your workflow with intelligent actions or explore real-world Joule integration scenarios, this guide will provide a practical starting point.

1. Create an Environment

We need to create an environment for testing joule skill.

Open the SAP Build Lobby, choose Control Tower->Environments and press the Create button.

Name your environment and add Description.

2. Exposing the Destination

Url of the destination on BTP is the url of our SAP system and the destination must have these properties:

sap.applicationdevelopment.actions.enabled -> true

sap.processautomation.enabled -> true

sap.build.usage -> odata_gen

Also the destination’s user will be used for set an external break-point for debugging the ABAP code.

Open the SAP Build Lobby, choose Control Tower->Destinations and press the Add button.

Select the Destination and choose next.

Choose the environment in which you want to use the target. For this tutorial you can choose the Test Environment that you create.

3. Create a database table to store purchase orders

@EndUserText.label : 'Purchase Order Change With Sap Build'
@AbapCatalog.enhancementCategory : #NOT_CLASSIFIED
@AbapCatalog.tableCategory : #TRANSPARENT
@AbapCatalog.deliveryClass : #A
@AbapCatalog.dataMaintenance : #ALLOWED
define table zbg_build_test {
  key mandt                      : mandt not null;
  key purchaseorder              : ebeln not null;
  key purchaseorderitem          : ebelp not null;
  key reservationitem            : ebelp not null;
  material                       : matnr;
  materialcompisvariablesized    : boolean;
  materialcomponentisphantomitem : boolean;
  reservation                    : char10;
  @Semantics.quantity.unitOfMeasure : 'zbg_build_test.entryunit'
  requiredquantity               : menge_d;
  requirementdate                : dats;
  reservationisfinallyissued     : boolean;
  baseunit                       : meins;
  @Semantics.quantity.unitOfMeasure : 'zbg_build_test.entryunit'
  quantityinentryunit            : menge_d;
  entryunit                      : meins;
  plant                          : werks_d;
  latestrequirementdate          : dats;
  billofmaterialitemnumber       : ebelp;
  bomitemcategory                : char1;
  isbulkmaterialcomponent        : boolean;
  debitcreditcode                : shkzg;
  @Semantics.quantity.unitOfMeasure : 'zbg_build_test.entryunit'
  withdrawnquantity              : menge_d;
  approver                       : uname;
  appoved                        : flag;

}

Fill the table:

4. Create a CDS from the ZTABLE for Odata

@AbapCatalog.sqlViewName: 'ZSLV_BUILD_TST_V'
@AbapCatalog.compiler.compareFilter: true
@AbapCatalog.preserveKey: true
@AccessControl.authorizationCheck: #NOT_REQUIRED
@EndUserText.label: 'Purchasing Document Informations CDS'
@Metadata.ignorePropagatedAnnotations: true
@ObjectModel.deleteEnabled: true
@ObjectModel.createEnabled: true
@ObjectModel.updateEnabled: true
define view ZSLV_V_BUILD_TEST as select from zbg_build_test as z 
    
{   @EndUserText.label: 'Purchase Order'
    key purchaseorder,
    @EndUserText.label: 'Purchase Order Item'
    key purchaseorderitem,
    @EndUserText.label: 'Reservation Item'
    key reservationitem,
    @EndUserText.label: 'Material'
    material,
    @EndUserText.label: 'Material Size'
    materialcompisvariablesized,
    @EndUserText.label: 'Material Item'
    materialcomponentisphantomitem,
    @EndUserText.label: 'Reservation'
    reservation,
    @EndUserText.label: 'Quantity'
    requiredquantity,
    @EndUserText.label: 'Date'
    requirementdate,
    @EndUserText.label: 'Reservation Issue'
    reservationisfinallyissued,
    @EndUserText.label: 'Unit'
    baseunit,
    @EndUserText.label: 'Entry Unit'
    entryunit,
    @EndUserText.label: 'Quantity In Entry Unit'
    quantityinentryunit,
    @EndUserText.label: 'Plant'
    plant,
    @EndUserText.label: 'Latest Requirement Date'
    latestrequirementdate,
    @EndUserText.label: 'Bill Of Material Number'
    billofmaterialitemnumber,
    @EndUserText.label: 'BOM Item Category'
    bomitemcategory,
    @EndUserText.label: 'Is Bulk Material'
    isbulkmaterialcomponent,
    @EndUserText.label: 'Debit Credit Code'
    debitcreditcode,
    @EndUserText.label: 'With Drawn Quantity'
    withdrawnquantity,
    @EndUserText.label: 'Approver'
    approver,
    @EndUserText.label: 'Approved'
    appoved 
    
}

5. Create OData service with T-code SEGW

(Because of the version of the system I work on, this guide uses SEGW instead of RAP to create an OData service. However, you can easily create your own OData service with RAP.)

Press ‘Create Project’ button, fill the fields and assign the package, request (For this tutorial it will be local object).

Complete the creation.

Extend the project, right click to ‘Data Model’, select the Reference->Source

Fill the CDS name that you created. Choose ‘Next’.

Choose ‘Finish’.

Activate and generate the Service:

Go to the class ZCL_ZSLV_BUILD_DPC_EXT. At the bottom of the method list redefine the update method ZSLV_V_BUILD_TES_UPDATE_ENTITY.

In the method, update the approved field with the below code and activate it.

METHOD zslv_v_build_tes_update_entity.
 
  DATA: lv_ebeln TYPE ebeln,
        lv_ebelp TYPE ebelp,
        lv_item  TYPE ebelp,
        ls_entity TYPE zcl_zslv_build_mpc=>ts_zslv_v_build_testtype,
        lr_entity TYPE REF TO data,
        ls_table TYPE zbg_build_test.
 
  LOOP AT it_key_tab INTO DATA(ls_key).
    CASE ls_key-name.
      WHEN 'purchaseorder'.
        lv_ebeln = ls_key-value.
      WHEN 'purchaseorderitem'.
        lv_ebelp = ls_key-value.
      WHEN 'reservationitem'.
        lv_item = ls_key-value.
    ENDCASE.
  ENDLOOP.
 
  io_data_provider->read_entry_data( IMPORTING es_data = ls_entity ).
  MOVE-CORRESPONDING ls_entity TO ls_table.
  er_entity = ls_entity.
  UPDATE zbg_build_test FROM ls_table.
  COMMIT WORK.
 
ENDMETHOD.

6. Activate the Odata service via /iwfnd/maint_service T-code

Choose ‘Add Service’

Select the ‘System Alias’, fill the ‘Technical Service Name’ and press ‘Get Services’. Select the service that you create and press ‘Add Selected Services’.

Assign the package and continue.

We have added the service, which should appear as follows. In the ICF Nodes section, there is a button labeled "SAP Gateway Client" that provides a testing environment for the service. Press that button.

Select the HTTP method as ‘GET’. Press ‘EntitySets’ to choose entity set. Choose the one that you created.

Press ‘Execute’ button for testing and response should appear as follows.

7. Crete an Action in SAP Build

Open the SAP Build Lobby, choose Connectors->Actions and press the ‘Create’ button. Choose ‘OData Destinations’ and select the Destination that we created.

Fill the Resource Path as follows and click ‘Next’.

The available methods are listed in this window. Select ‘Next’.

Fill the name and description for your action and create.

The action Purchase_Order_Action is created. Click the action and open it.

Select the methods in the OData Service.

The GET method's input has no required fields, only optional GET parameters.

Output parameters are the fields in the CDS that we created.

Methods can be tested in the action interface. For the GET method we don’t need to fill any input parameters. Click ‘Test’ button.

The data appears on the ‘Test Preview’ section.

The PATCH method requires purchaseorder, purchaseorderitem and reservationitem, all of which are key fields in our ZTABLE and CDS.

There are no standard output in PATCH method.

In the Test section, all required fields and fields that need to be changed must be filled out. In this scenario these fields are purchaseorder, purchaseorderitem, reservationitem and approved fields.

Also the link on the Test section can be used in the SAP Gateway Client to test the PATCH method.

PATCH method return “204: NO CONTENT” and empty Response. This means the update is successful and we will use this emptiness in our joule skill.

After checking and testing, save the methods using the ‘Save’ button and select ‘Release’. After the release process, the action should appear as shown below. Then, press 'Publish'.

You can debug when testing methods via the SAP Gateway Client or the SAP Build Action. Set an external breakpoint for the user in your destination that we created at the beginning.

For the PATCH method, our key fields in the internal table IT_KEY_TAB.

8. Create A Joule Skill to Get Purchase Order

Open the SAP Build Lobby, choose Create->Joule Skill and fill the name and description. Open the created skill.

Select the ’Trigger’ step. On the ‘General’ tab fill the name and description. Allow Joule to generate a response and skill to be started directly by user.

We don't need input, but outputs can vary according to our needs. In this tutorial, the parameters shown below have been added as outputs.

Choose ‘Configure’ and add parameters you want to show to the user. For this example, all parameters are string except the ‘approved’ which is boolean.

Press ‘+’ and choose ‘Call Action’, ‘Browse All Actions’.

Search for ‘ZSLV_V_BUILD_TEST’ or your Service Name. Add the ‘Get entities from ZSLV_V_BUILD_TEST’.

Select the ‘Destination Variable’ as Destination we created.

We can skip the input tab because there are no input for GET method.

We can see the output parameters in this tab.

On the "End" step, we need to assign the input and output parameters for the skills. Since we don't have any inputs, let's assign the outputs added in the "Trigger" step as our action's outputs.

Save the Joule Skill.

And Release.

Now Deploy.

Choose the Environment we created and click ‘Upgrade’.

Match the destinations, and the skill will be ready to use by Joule after deployment.

9. Create A Joule Skill to Approve Purchase Order

On the ‘Trigger’ step, fill the name and description. Deactivate the ‘Allow Joule to generate a response’ feature because in this skill we will create our own messages. The other feature should be active.

Configure the input parameters. Add purchaseorder, purchaseorderitem and reservationitem key fields as string. For approve skill we don’t need any output field.

Choose ‘+’ and ‘Call Action’.

Browse All Actions.

Search update or the service name. Add the Update entity in ZSLV_V_BUILD_TEST.

On the ‘General’ tab, assign the Destination.

On the ‘Inputs’ tab, assign the purchaseorder, purchaseorderitem and reservationitem to the parameters created on the "Trigger" step.

We only need to fill the fields ‘approved’ from the fields to be updated. We need to configure the ‘approved’ field because action inputs can only be string.

Choose ‘approved’ field and ‘Apply a formula’.

Type ‘true’ and click ‘Apply’.

Choose ‘+’ and ‘Check Condition’.

Choose the ‘Condition Editor’.

Add the following conditions and Click ‘Apply’. If PATCH method is executed successfully, the result will be empty.

If the condition is met, the left branch of the condition executes. In the opposite case, the ‘Default’ branch of the condition executes.

Choose the ‘+’ on the left branch and ‘Send Response’.

Open Message Editor.

Fill the parameters as shown below and save.

You can add parameters to the title and message with the ‘<>’ button.

Do the same steps for the right branch of the condition. ‘+’ -> ’Send Response’ -> ‘Open Message Editor’

Fill the parameters as shown below and save.

Save, Release and Deploy just like the previous GET_PURCHASE_ORDER skill.

10. Launch The Joule and Test The Skills

Open the SAP Build Lobby, choose Control Tower->Environments->Joule

Launch the joule, ask for Purchase Orders and get the details.

Ask joule to approve the purchase orders and get the illustrated success message card we create.

How to Test OAuth-Enabled Inbound Communication in SAP Using an API Client

2025-12-22T11:34:21.364000+01:00

Introduction

This blog post explains how to test OAuth-enabled inbound communication in SAP using an API client. It walks through the configuration steps and provides practical examples for validating the setup.

When working with inbound communication in SAP S/4HANA Cloud or on-premises systems, developers and integration specialists often need a lightweight tool to test APIs secured with OAuth 2.0.

While there are many API testing tools available today, this guide focuses on Bruno—a modern, open-source similar to the more established Postman. Personally I think of Postman as the old guard, and Bruno as the new pup on the block: sleek, efficient, and eager to fetch your tokens! (And yes, my love for dogs may have influenced this choice just a little.)

Image was created by the author using an AI illustration tool and is original content.

🐾 In this post, I’ll walk you through how to:

Configure a custom communication arrangement based on an existing communication scenario for OAuth 2.0
Use an API client to test inbound communication secured with OAuth 2.0

Note: This guide assumes you already have a communication scenario that supports OAuth 2.0.

Prerequisites

A communication scenario in your S/4HANA system that supports OAuth 2.0
An API client installed on your operating system (for example, Bruno, Postman, or any equivalent tool)

So, grab your treats and let’s get our paws dirty—Bruno’s ready to sniff out those OAuth tokens and help you unleash smoother integrations!

Step 1: Enable a Custom Communication Arrangement for OAuth

1. Create a Communication System and Communication User

🐾 Think of the Communication System as Bruno’s doghouse—it needs to be cozy, secure, and ready for visitors. 🐾

Open the Communication Systems app and create a new system:

System ID	Z_BRUNO
System Name	Z_BRUNO

Under Technical Data:

Enable Inbound Only.
In OAuth 2.0 Settings:
- Set Client Redirect URI Type to Loopback
- Set a path in the Path field, e.g., /bruno/redirect
  → This becomes your Callback URL: http://127.0.0.1/bruno/redirect (used in Step 2)

🐾 When you set the redirect path to /bruno/redirect, you’re basically telling Bruno where to wag his tail when he’s done fetching the token. 🐾

Under Users for Inbound Communication

Add a new communication user
Set Authentication Method to OAuth 2.0
Define OAuth 2.0 Client ID, e.g., Z_BRUNO_ID
Enable Refresh Allowed and set Refresh Token Expiry Time, e.g., 5 Days

Save your communication system and inbound communication user for your future testing with Bruno acting as OAuth client. This user will be later used for the Authorization Code Grant with PKCE.

2. Create a Communication Arrangement

Open the Communication Arrangements app and create a new arrangement based on a communication scenario that supports OAuth 2.0 as an authentication method, e.g., SAP_COM_0053 (Purchase Order Integration).

Scenario	SAP_COM_0053 (exists only in S/4HANA Cloud)
Arrangement Name	TEST_COM_0053_WITH_BRUNO
Communication System	Z_BRUNO (defined earlier)

Under Inbound Communication:

Enter the OAuth 2.0 Client ID you defined earlier: Z_BRUNO_ID.
Save your communication arrangement.

Note: Only after saving the arrangement, the previously defined OAuth client gets actually created. A clickable label OAuth 2.0 Details will apear.

In OAuth 2.0 Details, you will find all the necessary data for your API client:

Client ID
Token Service URL
Authorization URL

These are needed to fetch a token with Bruno.

Now you are ready to test your OAuth-secured API using Bruno!

Step 2: Use Bruno to Test the OAuth Communication

Image was created by the author using an AI illustration tool and is original content.

1. Create a New Collection

🐾 Creating a new collection in Bruno is like giving your dog a new toy—name it, set it up, and let the fun begin! 🐾

Open Bruno
Create a New Collection
Name it, e.g., My_test_collection

2. Set Up OAuth in the Auth Tab

Go to the Auth tab and choose OAuth 2.0
Set up the configurations:

Grant Type	Authorization Code
Callback URL	http://127.0.0.1/bruno/redirect
Authorization URL	From Communication Arrangement
Access Token URL	From Communication Arrangement
Client ID	From Communication Arrangement
State	dummy
Use PKCE check box	✅enabled

🐾 Don’t forget to enable PKCE—it’s like putting a leash on your OAuth flow. Keeps things secure and under control. 🐾

3. Send a Test Request

Choose Get Access Token
A browser window will open - logon as a Business User
Approve the request by clicking Allow
If successful, you’ll receive an Access Token.
The response typically appears in the Response tab in JSON format like this:
Use this token to call your API services:

Troubleshooting Tips

Make sure you log in with a Business User assigned to the correct Business Roles for the API.
If you see the following screen after logging in:

it likely means the user lacks the required authorizations or the wrong user was used.

Summary

With this setup, you can securely test OAuth-protected endpoints in SAP using Bruno or similar tools. This approach is useful for validating integration scenarios and troubleshooting authentication issues.

Bruno provides a clean and open-source alternative to Postman for testing OAuth-secured APIs in SAP S/4HANA. With just a few configuration steps, you can simulate real-world OAuth flows and validate your communication scenarios with ease.

🐾 With Bruno by your side, testing OAuth APIs is less of a chore and more of a walk in the park. Just don’t forget the treats (a.k.a. access tokens)! 🐾

Image Attribution and Licensing

All illustrations in this post were created by the author using Microsoft Copilot (AI-based design tool) for educational purposes. The images are original content and free to use under the author’s permission for non-commercial, educational purposes. No external branding or promotional elements are included.

How to Use SAP Extensibility Wizard in SAP S/4HANA Clean Core

2025-12-23T07:13:48.565000+01:00

A Comprehensive Guide to Extending SAP S/4HANA with the SAP Extensibility Wizard — Without Compromising Your Clean Core

Introduction

Extensibility is a critical aspect of SAP S/4HANA, enabling organizations to tailor the system to their unique business needs while maintaining stability and upgrade readiness. In this guide, we will explore the SAP Extensibility Wizard, a powerful tool designed to help developers extend SAP S/4HANA in a clean and controlled way.

What Is the SAP Extensibility Wizard?

The SAP Extensibility Wizard is a guided tool provided by SAP that simplifies the process of creating extensions. It ensures that developers can add custom functionality without modifying the core system, thereby preserving the clean core principle. This approach guarantees that upgrades remain smooth and that the system stays resilient over time.

Availability: Public Cloud vs. Private Cloud

A common question arises: Is the SAP Extensibility Wizard available only in the Public Cloud, or also in the Private Cloud?

Public Cloud (SAP S/4HANA Cloud – Public Edition):
The wizard is primarily available here. It supports clean-core extensibility and helps organizations build safe, upgrade‑friendly extensions.
Private Cloud / On‑Premise:
Extensibility is possible through other approaches such as in‑app extensibility, ABAP Cloud, and side‑by‑side extensions on SAP BTP. However, the wizard itself is not provided in the same way as in the Public Cloud.

In summary:

Public Cloud → Wizard available.
Private Cloud / On‑Premise → Extensibility options exist, but without the wizard.

Focus of This Blog

This blog will focus on the SAP Extensibility Wizard for SAP S/4HANA Cloud – Public Edition.

How to Use the Extensibility Wizard

With the SAP S/4HANA Cloud Public Edition extensibility wizard, developers can:

Create on‑stack extensions such as custom fields and custom logic.
Build side‑by‑side extensions like custom processes using SAP Build Process Automation.

This guided approach ensures that extensions are implemented efficiently, securely, and in alignment with SAP’s clean‑core strategy.

Conclusion

The SAP Extensibility Wizard is a key enabler for organizations running SAP S/4HANA Cloud Public Edition. By leveraging this tool, businesses can extend their systems with confidence, ensuring that customizations remain upgrade‑safe and future‑proof.

Detailed Steps:

Use Case : We will create a sales order approval process .

1. Navigate to SAP S4/HANA Fiori Launchpad.

1.1 Select Business Application Manage Sales Orders.

1.2 Navigate to Create Extension

1.3 In this case , we will select custom process.

The process can start based on various triggers

1.4 Select Business Event from SAP S4/HANA, that Triggers the process

1.5 Select Event Object

1.6 Select the SalesOrder create event.

1.7 Click Preview to see all the options you selected on previous screens, and make any necessary corrections.

1.8 Click Create , to create the process in SAP Build.

1.9 The extension is now available and can also be opened in SAP Build.

1.10 When you select Open Extension, the system launches another tab that opens the process.

1.11 The Process Automation project overview page is now displayed. Select SalesOrder Approval.

1.12 Extension is now openEd in SAP Build , Start design of the process.

The Business context is carried over from SAP S4/HANA to SAP Build .

1.13 You can add an action, form , or approval . To get further details on the sales order, you need to call an action .

1.14 In this use case , we will call sales order read API , to fetch the sales order details.

1.15 Browse the library to search for the relevant APIs .

1.16 Select read sales order API to get details of the sales order, The business context and system ID were automatically pulled in from SAP S4/HANA .

1.17 The action to read the sales order has now been added . Now users can design the process according to their needs. The user now wants to initiate a workflow that sends an email to the approver for sales order approval .

1.18 The email will include the sales order details , allowing approver to review and approve it . we're utilizing AI to generate the process , Enter the prompt to add an approval step and send the sales order details to the approver via email.

1.19 AI has now added the process step to read the sales order and email, The sales order details to the approver .

Conclusion

The SAP Extensibility Wizard empowers organizations running SAP S/4HANA Cloud Public Edition to extend their systems safely and efficiently, without compromising the clean core. By leveraging guided tools for custom fields, logic, and side‑by‑side processes, businesses can innovate while staying upgrade‑ready.

Extensibility in SAP is not just about adding features—it’s about doing so in a way that keeps your system future‑proof. With the wizard, you can confidently build the extensions your business needs today, while ensuring smooth upgrades tomorrow.

How to Create a ServiceNow Incident via REST API Using ABAP (OAuth 2.0)

2025-12-29T08:34:25.619000+01:00

Prerequisites

ServiceNow instance access with API credentials (Client ID, Client Secret)
SAP NetWeaver with HTTP Client (CL_HTTP_CLIENT) and JSON support (/UI2/CL_JSON)

Step 1: Obtain OAuth2 Token from ServiceNow

First, you need to POST your client credentials to ServiceNow’s /oauth_token endpoint to get a bearer token. This token authorizes subsequent API calls.

ABAP Code:

FORM get_servicenow_token USING iv_token_url TYPE string
                              iv_client_id TYPE string
                              iv_client_secret TYPE string
                         CHANGING cv_token TYPE ty_token
                                  cv_errmsg TYPE string.

  DATA: lv_payload     TYPE string,
        lo_http_client TYPE REF TO if_http_client,
        lv_response    TYPE string,
        lt_token       TYPE STANDARD TABLE OF ty_token,
        lo_json        TYPE REF TO /ui2/cl_json.

  CLEAR: cv_errmsg, cv_token.

  lv_payload = |grant_type=client_credentials&client_id={ iv_client_id }&client_secret={ iv_client_secret }|.

  CALL METHOD cl_http_client=>create_by_url
    EXPORTING
      url    = iv_token_url
    IMPORTING
      client = lo_http_client
    EXCEPTIONS
      OTHERS = 1.

  IF sy-subrc <> 0 OR lo_http_client IS INITIAL.
    cv_errmsg = 'Failed to create HTTP client for token.'.
    EXIT.
  ENDIF.

  lo_http_client->request->set_method( 'POST' ).
  lo_http_client->request->set_header_field( name = 'Content-Type' value = 'application/x-www-form-urlencoded' ).
  lo_http_client->request->set_cdata( lv_payload ).

  TRY.
      lo_http_client->send( ).
      lo_http_client->receive( ).
      lv_response = lo_http_client->response->get_cdata( ).
      lo_http_client->close( ).
      CONCATENATE '[' lv_response ']' INTO lv_response.

      CREATE OBJECT lo_json.
      lo_json->deserialize( EXPORTING json = lv_response CHANGING data = lt_token ).
      IF lt_token IS NOT INITIAL.
        READ TABLE lt_token INDEX 1 INTO cv_token.
      ELSE.
        cv_errmsg = 'Could not parse token from JSON.'.
      ENDIF.
    CATCH cx_root INTO DATA(lx_err).
      cv_errmsg = lx_err->get_text( ).
  ENDTRY.
ENDFORM.

If successful, the access_token can now be used as a Bearer token.

Step 2: Build the JSON Payload

Create a JSON structure that describes the incident.

ABAP Code:

lv_json_body =
'{' &&
'"caller_id":"ABC Corp",' &&
'"service_offering":"SAP Material",' &&
'"category":"Data",' &&
'"subcategory":"Incorrect Data",' &&
'"short_description":"Test Incident from SAP",' &&
'"description":"Test Incident from SAP",' &&
'"impact":"2",' &&
'"urgency":"2"' &&
'}'.

Step 3: Create the Incident via POST API

Now, make a POST request to the ServiceNow incident table, including your access token for authorization.

ABAP Code:

FORM create_servicenow_incident
  USING iv_post_url TYPE string
        iv_access_token TYPE string
        iv_body TYPE string
  CHANGING cv_result TYPE string
           cv_errmsg TYPE string.

  DATA: lo_http_client TYPE REF TO if_http_client.

  CLEAR: cv_errmsg, cv_result.

  CALL METHOD cl_http_client=>create_by_url
    EXPORTING
      url    = iv_post_url
    IMPORTING
      client = lo_http_client.

  lo_http_client->request->set_method( 'POST' ).
  lo_http_client->request->set_header_field( name = 'Content-Type' value = 'application/json' ).
  lo_http_client->request->set_header_field( name = 'Accept' value = 'application/json' ).
  lo_http_client->request->set_header_field( name = 'Authorization' value = |Bearer { iv_access_token }| ).
  lo_http_client->request->set_cdata( iv_body ).

  TRY.
      lo_http_client->send( ).
      lo_http_client->receive( ).
      cv_result = lo_http_client->response->get_cdata( ).
      lo_http_client->close( ).
    CATCH cx_root INTO DATA(lx_err).
      cv_errmsg = lx_err->get_text( ).
  ENDTRY.
ENDFORM.

If successful, cv_result will contain the incident response from ServiceNow.

Step 4: Combine the Steps in Your Report

Your main program calls these subroutines in sequence.

Example Main Logic:

* Get the access token
PERFORM get_servicenow_token
               USING lv_token_url
                     lv_client_id
                     lv_client_secret
               CHANGING ls_token
                     lv_err.

IF lv_err IS NOT INITIAL OR ls_token-access_token IS INITIAL.
  WRITE: / 'Token Error:', lv_err.
  EXIT.
ENDIF.

* Create the incident
PERFORM create_servicenow_incident
                    USING lv_post_url
                          ls_token-access_token
                          lv_json_body
                   CHANGING lv_result
                            lv_err.

IF lv_err IS INITIAL.
  WRITE: / 'Incident Response:', lv_result.
ELSE.
  WRITE: / 'Incident Creation Error:', lv_err.
ENDIF.

Final Notes

Security: Never hardcode sensitive data in productive programs—use secure storage.
Error Handling: Always add robust error handling and log failures for troubleshooting.
Data Mapping: Adjust JSON fields based on ServiceNow table and your organization’s requirements.

Conclusion

Integrating SAP and ServiceNow allows you to automatically manage ITSM incidents directly from SAP ABAP. The above example demonstrates OAuth token retrieval and incident creation using ABAP. Adapt and build on this foundation to suit your business requirements.

Happy Integrating! Let me know in the comments if you have any questions or need clarification on any step.

Complete ABAP CODE:

*&---------------------------------------------------------------------*
*& Report ZSNOW
*---------------------------------------------------------------------*
* Utility: ServiceNow Incident API Integration
*---------------------------------------------------------------------*

REPORT zsnow.

TYPES: BEGIN OF ty_token,
         access_token TYPE string,
         scope        TYPE string,
         token_type   TYPE string,
         expires_in   TYPE i,
       END OF ty_token.

DATA: lv_token_url     TYPE string VALUE 'https://://<your-comapny-domain>.service-now.com/oauth_token',
      lv_client_id     TYPE string VALUE '...your-client-id...',
      lv_client_secret TYPE string VALUE '...your-client-secret...',
      lv_post_url      TYPE string VALUE 'https://://<your-comapny-domain>.service-now.com/api/now/table/incident',
      lv_json_body     TYPE string,
      ls_token         TYPE ty_token,
      lv_err           TYPE string,
      lv_result        TYPE string.

* Prepare JSON Body

lv_json_body = '{' &&
               '"caller_id":"ABC Corp",' &&
               '"service_offering":"SAP Material",' &&
               '"category":"Data",' &&
               '"subcategory":"Incorrect Data",' &&
               '"short_description":"Test Incident from SAP",' &&
               '"description":"Test Incident from SAP",' &&
               '"impact":"2",' &&
               '"urgency":"2"' &&
               '}'.

* Step 1: Get the Token
PERFORM get_servicenow_token USING lv_token_url
                                   lv_client_id
                                   lv_client_secret
                          CHANGING ls_token
                                   lv_err.

IF lv_err IS NOT INITIAL OR ls_token-access_token IS INITIAL.
  WRITE: / 'Token Error:', lv_err.
  EXIT.
ENDIF.

* Step 2: Create Incident
PERFORM create_servicenow_incident USING lv_post_url
                                         ls_token-access_token
                                         lv_json_body
                                CHANGING lv_result
                                         lv_err.

IF lv_err IS INITIAL.
  WRITE: / 'Incident Response:', lv_result.
ELSE.
  WRITE: / 'Incident Creation Error:', lv_err.
ENDIF.



*--------------------------------------------------------*
* Get OAuth Token from ServiceNow
*--------------------------------------------------------*
FORM get_servicenow_token
  USING    iv_token_url TYPE string
           iv_client_id TYPE string
           iv_client_secret TYPE string
  CHANGING cv_token TYPE ty_token
           cv_errmsg TYPE string.

  DATA: lv_payload     TYPE string,
        lo_http_client TYPE REF TO if_http_client,
        lv_response    TYPE string,
        lt_token       TYPE STANDARD TABLE OF ty_token,
        lo_json        TYPE REF TO /ui2/cl_json.

  CLEAR: cv_errmsg, cv_token.

  lv_payload = |grant_type=client_credentials&client_id={ iv_client_id }&client_secret={ iv_client_secret }|.

  CALL METHOD cl_http_client=>create_by_url
    EXPORTING
      url    = iv_token_url
    IMPORTING
      client = lo_http_client
    EXCEPTIONS
      OTHERS = 1.

  IF sy-subrc <> 0 OR lo_http_client IS INITIAL.
    cv_errmsg = 'Failed to create HTTP client for token.'.
    EXIT.
  ENDIF.

  lo_http_client->request->set_method( 'POST' ).
  lo_http_client->request->set_header_field( name = 'Content-Type' value = 'application/x-www-form-urlencoded' ).
  lo_http_client->request->set_cdata( lv_payload ).

  TRY.
      lo_http_client->send( ).
      lo_http_client->receive( ).
      lv_response = lo_http_client->response->get_cdata( ).
      lo_http_client->close( ).
      CONCATENATE '[' lv_response ']' INTO lv_response.

      CREATE OBJECT lo_json.
      lo_json->deserialize( EXPORTING json = lv_response CHANGING data = lt_token ).
      IF lt_token IS NOT INITIAL.
        READ TABLE lt_token INDEX 1 INTO cv_token.
      ELSE.
        cv_errmsg = 'Could not parse token from JSON.'.
      ENDIF.
    CATCH cx_root INTO DATA(lx_err).
      cv_errmsg = lx_err->get_text( ).
  ENDTRY.

ENDFORM.                    " get_servicenow_token

*--------------------------------------------------------*
* Create an Incident in ServiceNow
*--------------------------------------------------------*
FORM create_servicenow_incident
  USING iv_post_url TYPE string
        iv_access_token TYPE string
        iv_body TYPE string
  CHANGING cv_result TYPE string
           cv_errmsg TYPE string.

  DATA: lo_http_client TYPE REF TO if_http_client.

  CLEAR: cv_errmsg, cv_result.

  CALL METHOD cl_http_client=>create_by_url
    EXPORTING
      url    = iv_post_url
    IMPORTING
      client = lo_http_client.

  lo_http_client->request->set_method( 'POST' ).
  lo_http_client->request->set_header_field( name = 'Content-Type' value = 'application/json' ).
  lo_http_client->request->set_header_field( name = 'Accept' value = 'application/json' ).
  lo_http_client->request->set_header_field( name = 'Authorization' value = |Bearer { iv_access_token }| ).
  lo_http_client->request->set_cdata( iv_body ).

  TRY.
      lo_http_client->send( ).
      lo_http_client->receive( ).
      cv_result = lo_http_client->response->get_cdata( ).
      lo_http_client->close( ).
    CATCH cx_root INTO DATA(lx_err).
      cv_errmsg = lx_err->get_text( ).
  ENDTRY.

ENDFORM.                    " create_servicenow_incident

Building an Email-Based SAP Sales Order Automation with n8n & AI Function Calling

2026-01-27T08:02:05.123000+01:00

Building an Email-Based SAP Sales Order Assistant with AI Function Calling

The Problem That Started This

A few weeks ago, I was watching a colleague struggle with a simple request: "Can you check if order 10850 shipped?" They had to VPN in, open SAP GUI, navigate to VA03, enter the order number, and finally get the answer. For one question. That took 3 minutes.

I thought - what if they could just send an email and get an answer back?

Why Not Just Use Rules or Keywords?

My first instinct was simple pattern matching. Look for "create order" then run the create flow. Look for "check status" then run the query flow. Easy, right?

Then I looked at actual emails people send:

"Hey, can you set up an order for 17100003? They need 5 of TG11 and 10 of TG12"
"pls make SO for cust 17100003 - TG11 x5, TG12 x10"
"Customer 17100003 wants to place an order. Materials: TG11 (5 units), TG12 (10 units)"

Same request, completely different wording. Building regex patterns for every variation? That's a maintenance nightmare waiting to happen. And what about typos, abbreviations, or when someone writes in a mix of languages?

This is exactly where AI shines - understanding intent regardless of how it's expressed.

Why Function Calling Instead of Free-Form AI?

I didn't want the AI making up SAP field names or guessing at API structures. That's a recipe for errors. Function calling gives you the best of both worlds:

The AI handles the messy, unpredictable part (understanding what the user wants)
The code handles the precise, structured part (calling SAP correctly)

You define exactly what functions exist and what parameters they accept. The AI picks the right function and extracts the right values. No hallucinated field names, no invented API calls.

The Architecture

Four components working together:

Microsoft Outlook - Triggers when an email arrives
LLM with Function Calling - Interprets the email, picks the operation
n8n - Orchestrates everything, handles data transformation
SAP S/4HANA OData APIs - Does the actual work

Setting Up n8n with Docker (The Network Gotchas)

I run n8n locally in Docker, and connecting it to an on-premise SAP system over VPN was... an adventure. Here's what I learned.

The Basic Setup

docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  --add-host=host.docker.internal:host-gateway \
  -v n8n_data:/home/node/.n8n \
  docker.n8n.io/n8nio/n8n

That --add-host=host.docker.internal:host-gateway flag is crucial. It lets containers reference your host machine's network. Without it, your container is isolated and can't see anything your host can see - including VPN connections.

The VPN Problem

Here's the thing: when you connect to a VPN on your Mac, the VPN routes are available to your host machine, but Docker containers live in their own network namespace. They can't directly reach 172.16.0.11:44300 even though your browser can.

You might think "just use --network host" - but on macOS, that doesn't work the way you'd expect. Docker Desktop on Mac runs containers in a Linux VM, so --network host gives you the VM's network, not your Mac's network.

The socat Bridge Solution

The workaround is to run a TCP forwarder on your host that bridges the connection:

socat TCP-LISTEN:15001,fork,reuseaddr TCP:172.16.0.11:44300

This listens on port 15001 on your Mac and forwards traffic to the SAP server at 172.16.0.11:44300. Now from inside Docker, you can reach SAP at:

https://host.docker.internal:15001/sap/opu/odata/sap/API_SALES_ORDER_SRV/A_SalesOrder

The flow is: Docker container → host.docker.internal:15001 → socat on your Mac → VPN → SAP server

Keep the socat command running in a terminal while you're working. Kill it when you're done.

Quick Tip: If you're getting "connection refused" errors, check that:

Your VPN is connected
socat is running
You're using host.docker.internal, not localhost or the direct IP

The Functions I Defined

Three operations cover most daily requests:

get_sales_orders

"Show me recent orders," "What's the status of order X?"

Parameters: $top, $filter, $orderby

create_sales_order

"Create an order for customer X with these items"

Parameters: SoldToParty, items[] (Material, RequestedQuantity), plus optional fields

update_sales_order

"Change the PO reference on order 10904"

Parameters: SalesOrder (required), plus any fields to update

When an email comes in, the AI returns structured JSON:

{
  "function": "create_sales_order",
  "arguments": {
    "SoldToParty": "17100003",
    "items": [
      {"Material": "TG11", "RequestedQuantity": "5"},
      {"Material": "TG12", "RequestedQuantity": "10"}
    ]
  }
}

Clean, predictable, easy to work with.

The CSRF Token Headache

I have to mention this because it cost me hours. SAP OData APIs require CSRF tokens for write operations. Sounds simple - fetch a token, send it with your POST. But here's what the documentation doesn't make obvious:

The token is tied to your session cookies. You need to:

GET request with x-csrf-token: fetch header
Capture the token AND the SAP_SESSIONID cookie from the response
Send BOTH with your write request

I kept getting "CSRF token validation failed" with a perfectly valid token. Turns out I was missing the session cookie. The token alone is useless without it.

Another gotcha in n8n

The cookie header comes back with extra metadata like path=/; secure; HttpOnly. If you pass that whole string in your Cookie header, you'll get "Invalid character in header content." You need to extract just the cookie value:

// In an Edit Fields node, clean the cookie
$json.headers['set-cookie'][0].split(';')[0] + '; ' + 
$json.headers['set-cookie'][1].split(';')[0]

This gives you a clean sap-usercontext=sap-client=100; SAP_SESSIONID_S4H_100=abc123... that SAP will accept.

Data Transformation for Deep Insert

One more SAP quirk: when creating an order with line items, you can't just send an items array. SAP expects a nested structure called to_Item.results. In n8n's Code node:

const args = JSON.parse(
  $input.first().json.choices[0].message.tool_calls[0].function.arguments
);
const body = { ...args };

if (body.items) {
  body.to_Item = { results: body.items };
  delete body.items;
}

return [{ json: { sapBody: body } }];

This transforms the AI's clean output into SAP's expected format.

A Real Example

Input Email

Hello, please create a sales order with the following details:
Customer: 17100003
Sales Org: 1710
Items: TG11 (qty 5), TG12 (qty 10)
Currency: USD

What Happens

AI identifies this as create_sales_order
Extracts: customer, items array, currency
Workflow fetches CSRF token + session cookie
Transforms items array to SAP's to_Item.results format
POSTs to /sap/opu/odata/sap/API_SALES_ORDER_SRV/A_SalesOrder
SAP creates order, returns details

Response Email

The user never touched SAP. They just sent an email.

What's Next

The same pattern works for anything with an OData API:

Invoice queries
Delivery status checks
Material lookups
Customer master updates

Define the function, connect the endpoint, done.

The Takeaway

AI isn't replacing SAP knowledge here - it's translating between human language and system requirements. The business logic, the validations, the actual processing - that's all still SAP. The AI just makes it accessible to people who don't speak SAP.

And honestly? That's the kind of AI use case I find most valuable. Not replacing expertise, but removing friction.