Category: SAP

Preface – This post is part of the SAP ABAP OData Tutorial series.

Delete operation is used when you want to remove a record from the database. For example, you have created one quotation and now you no longer want it. So you will delete the quotation using the DELETE request.

This article describes the step-by-step procedure to implement and test delete operation in SAP OData.

Context

Delete entity can be implemented by redefining the DELETE_ENTITY method.

Procedure

1. Open *DPC_EXT class artifact of OData and redefine *DELETE_ENTITY method.
2. Reimplement the delete method.
   
   IT_KEY_TAB holds the values from the frontend.
3. Activate the class and register the service.
4. Execute and test the OData.
   1. Select Entity set
   2. Select DELETE option
   3. Add the key value to be deleted in the request URL
   4. Execute the request
      
   5. Status 204 represents success.
   6. Verify in the table the record is successfully deleted.

Tutorial Video

You can watch the below video to learn implementation:

[embedyt] https://www.youtube.com/watch?v=2rEZrFj2haE[/embedyt]

Preface – This post is part of the SAP ABAP OData Tutorial series.

Many times, we come across a scenario where we want to update the data records, for example, we want to update the phone number or address.

This article describes the step-by-step procedure to implement and test update operations in SAP OData.

Context

Update entity can be implemented by the redefining UPDATE_ENTITY method.

1. Using PUT HTTP method.
2. Using PATCH HTTP method.

Difference between PUT and PATCH HTTP method

• PUT: The request body is considered as the updated version of the original data stored in the database. When using PUT, we need to send the full payload in our request.
• PATCH: It is used for the partial modification of the resource. When using PATCH, we only send the data to be modified in the request body.

Procedure

1. Open *DPC_EXT class artifact of OData and redefine *UPDATE_ENTITY method.
2. Reimplement the method for the update.
   
3. Activate the class and register the service.
4. Execute and test the OData.
   1. Select Entity set
   2. Get the data to be updated using the GET request
   3. Click on Use as Request to copy the HTTP response to HTTP request which works as input.
      
   4. Change the field value Carname and URL in HTTP Request
   5. Select PUT option
   6. Add the key value to be updated in the request URL
   7. Execute the request
      
   8. Status code 204 represents success
      
   9. Verify-in the table data is successfully updated.
      

Tutorial Video

You can watch the below video to learn implementation:

[embedyt] https://www.youtube.com/watch?v=2rEZrFj2haE[/embedyt]

Preface – This post is part of the SAP ABAP OData Tutorial series.

Context

Create entity can be implemented in two ways:

1. Using CREATE_ENTITY method for single entity creation.
2. Using CREATE_DEEP_ENTITY method to create a single entity as well as parent and child entity together.

Procedure

1. Open *DPC_EXT class artifact of OData and redefine *CREATE_ENTITY method.

2. Reimplement the method.

method PARTNERS_CREATE_ENTITY.

  data: lv_id                type          snwd_partner_id,
        ls_id                type          bapi_epm_bp_id,
        ls_header            type          bapi_epm_bp_header,
        lt_return            type 	      table of bapiret2,
        error_msg            type          string,
        ls_message           type          scx_t100key,
        lt_keys              type          /iwbep/t_mgw_tech_pairs,
        ls_snwd_bpa          type          snwd_bpa,
        lv_timestamp         type          timestamp.

  io_data_provider->read_entry_data( importing es_data = ls_header ).

  CALL FUNCTION 'BAPI_EPM_BP_CREATE'
    EXPORTING
      HEADERDATA        = ls_header " EPM: BP header data
    IMPORTING
      BUSINESSPARTNERID = ls_id
    TABLES
      RETURN     = lt_return.     

  if lt_return is not initial.
    loop at lt_return reference into data(lr_return).
      err_msg = lr_return->message .
    endloop.

    ls_message-msgid = 'SY'.
    ls_message-msgno = '002'.
    ls_message-attr1 = error_msg.

    raise exception type /iwbep/cx_mgw_busi_exception
      EXPORTING
        textid = ls_message.
  endif.

  CALL FUNCTION 'BAPI_EPM_BP_GET_DETAIL'
    EXPORTING
      BP_ID             = ls_id
    IMPORTING
      HEADERDATA        = er_entity
endmethod. 

The input data is passed in es_data structure and captured in ls_header. The structure ls_header is then used as the input parameter of BAPI ‘BAPI_EPM_BP_CREATE’ to create data in the database. Then BAPI ‘BAPI_EPM_BP_GET_DETAIL’ will retrieve the created data and capture it in er_entity which will be passed to the response body.

3. Activate the class.

4. Create Deep Entity (To create Header with Item): Redefine method /IWBEP/IF_MGW_APPL_SRV_RUNTIME~CREATE_DEEP_ENTITY

5. Reimplement the method.

method /IWBEP/IF_MGW_APPL_SRV_RUNTIME~CREATE_DEEP_ENTITY.

 types: ty_t_soitem type standard table of  zcl_z_epm_rkt_mpc=>ts_salesorderitem with default key.
 types: begin of ty_s_so.
          include type zcl_z_epm_rkt_mpc=>ts_salesorder.
           types: items type ty_t_soitem,
         end of ty_s_so.

  data: ls_sales_order     type ty_s_so,
        lv_compare_result  type /iwbep/if_mgw_odata_expand=>ty_e_compare_result.

  data: lv_so_id    type BAPI_EPM_SO_ID,
        ls_so_hdr    type BAPI_EPM_SO_HEADER,
        ls_so_hdr2   type BAPI_EPM_SO_HEADER,
        ls_so_item   type BAPI_EPM_SO_ITEM,
        lt_so_item   type standard table of BAPI_EPM_SO_ITEM,
        lt_so_item2  type standard table of BAPI_EPM_SO_ITEM,
        lt_return   type bapirettab,
        ls_return   TYPE bapiret2,
        ls_message  type scx_t100key,
        error_msg     type string.

  constants: lc_so_itm TYPE string VALUE 'Items'.

* Validate whether data matches
  lv_compare_result = io_expand->compare_to( lc_so_itm ).

* Access data from IO_DATA_PROVIDER
  if lv_compare_result EQ /iwbep/if_mgw_odata_expand=>gcs_compare_result-match_equals.
io_data_provider->read_entry_data( IMPORTING es_data = ls_sales_order ).

*   Move header Sales order data into BAPI structure
    move-corresponding ls_sales_order to ls_so_hdr.

*   Move Sales Order items into BAPI table structure
    loop at ls_sales_order-items into ls_so_item.
       append ls_so_item to lt_so_item.
    endloop.

    CALL FUNCTION 'BAPI_EPM_SO_CREATE'
      EXPORTING
        HEADERDATA          = ls_so_hdr
      IMPORTING
        SALESORDERID        = lv_so_id
      TABLES
        ITEMDATA            = lt_so_item
        RETURN              = lt_return.

    if lt_return is not initial.
      loop at lt_return into ls_return.
        err_msg = ls_return-message .
      endloop.

      ls_message-msgid = 'SY'.
      ls_message-msgno = '002'.
      ls_message-attr1 = error_msg.

      raise exception type /iwbep/cx_mgw_busi_exception
        exporting
          textid = ls_message.
    else.

      CALL FUNCTION 'BAPI_EPM_SO_GET_DETAIL'
        EXPORTING
          SO_ID            = lv_so_id
        IMPORTING
          HEADERDATA       = ls_so_hdr2
        TABLES
          ITEMDATA         = lt_so_item2.
      move-corresponding ls_so_hdr2 to ls_sales_order.
      ls_sales_order-items = lt_so_item2.

      copy_data_to_ref(
      EXPORTING
        is_data = ls_sales_order
      CHANGING
        cr_data = er_deep_entity ).
    endif.
  endif.
endmethod. 

The structure of incoming data contains parent and child entity nested structure. This is defined with type ty_s_so.

6. Activate the class

7. Execute the Create request.

• Select Entity Set
• Select HTTP method as POST
• Add the data in the request body
• Click Execute

Tutorial Video

You can watch the below video to learn implementation:

[embedyt] https://www.youtube.com/watch?v=2rEZrFj2haE[/embedyt]

Preface – This post is part of the SAP ABAP OData Tutorial series.

Introduction

Postman is an API development tool that helps developers to create, test, share and document the APIs. It has various HTTP requests like GET, POST, PUT, PATCH and the ability to save the environment.

In this article, we will learn how to set up the POSTMAN and then we will test OData CRUD operations using POSTMAN.

 

Installing POSTMAN

To install POSTMAN on your device you can use the link go.postman.co/home and download the latest version for your platform.

For more details on installing and updating POSTMAN, you can refer to the link https://learning.postman.com/docs/getting-started/installation-and-updates/

 

Components of POSTMAN

Postman UI is made up of various components.

• Left sidebar provides the navigation to Collections, APIs, Environments, Mock Servers, Monitors and History.
• Header provides the access to Workspace, Reports, and Search option.
• Center area is where we work with requests.
• Right sidebar provides the link to Comments, Request Info’s, Code and Documentations.

 

Variables

We will use the variables to store our data which will be reused multiple times.

You can create variables by clicking ENVIRONMENT in the left panel and selecting GLOBAL.

Here you create variables and provide initial and current value. In case you need to change the value of the variable you only need to update the CURRENT VALUE field. This is the field from where the data is picked up.

Scope of variables:

• Global scope: Enable you to use data between the Collection, requests, test scripts and environment.
• Collection: Enable you to use data in different requests under the same collection.
• Environment: Enables to tailor the processing to different environments.
• Data: Comes from external files like CSV, JSON.
• Local: The scope is temporary and can only be used in the defined requests.

Create variable

1. Select data and click on Set as Variable.
   
2. Select Set as new Variable.
   
3. Provide name, value and scope.
   

 

Format to use variables in request: {{variable_name}}

Example:  .

 

HTTP requests

There are various HTTP methods available that are used to make a request to APIs. Some of the frequently used HTTP methods are:

• GET: Used to retrieve data from APIs (Read scenario)
• POST: Used to send new data to API (Create scenario)
• PUT or PATCH: Used to update existing data (Update scenario). PUT request modifies the entire resource in the database whereas PATCH request modifies only the supplied resource. So, while using PUT we need to send the entire data in request URI and by using PATCH we need to send only the updatable field.
• DELETE: Used to remove existing record (Delete scenario)

It supports various addition methods. Refer to the below snip.

Creating requests

You can create a request by clicking on the NEW tab and selecting HTTP Request. Also, you can create a request by clicking + button.

After selecting HTTP Request, a screen will open. Provide relevant name, description to your HTTP request.

Specify the relevant details for your requests (like HTTP method, URL, parameters, body data).

Click on SEND button to save your call. You can create a collection to save all your related requests under one folder.

 

Collection

A collection is a folder that groups the number of API requests. There can be n number of collections in Postman. Generally, an API request belonging to the same business object is saved under  the same Collection. You can even share your API requests with your team via collection.

Authentication

Authentication is verifying the client’s identity who is accessing the request whereas authorization is verifying the client’s action of permission. Some APIs require authorization details act.

To provide authorization details, click on the Authorization tab and select auth Type. Provide the relevant details and SAVE.

There are various auth types, for more details check out Authorizing requests.

Instead of adding an authorization in each request individually, you can add your authorization details directly to your Collection.

Steps:

1. Select TYPE as Inherit auth from parent.
   
2. Click Collection and add authorization details there.
   

Sending requests

GET request

Steps to follow:

1. Click on the NEW button and select HTTP request
   
   

 

2. Select HTTP request GET and enter OData service URL in URL field
   

 

3. Click on the Send button
   

 

At the bottom, you can see the output and status code.

 

Fetch x-csrf-token

An x-csrf-token is used to prevent cross-site request forgery attacks. While making a call for Create/Update/Delete we must need to send x-csrf-token value via Header.

Steps to fetch the x-csrf-token value.

1. Create a GET
2. Add in HEADERS: key = x-csrf-token and value = fetch.
   
3. Execute the request by clicking on SEND
4. Below you will get the result. In the Header section of the result you can find fetched x-csrf-token value. Get that value and paste it in HEADERS section of CUD requests.

 

POST request

1. Select HTTP request POST and enter OData service URL for create in URL field. (Do not provide the key field and its value in URI)
   
2. Provide x-csrf-token parameter in HEADERS (To fetch x-csrf-token refer How to fetch x-csrf-token?).
   
3. Provide the data to be created in the BODY tab and select the relevant data type. Here, we have selected raw.
   
4. Save and click on Send to execute the request.

 

PUT/PATCH request

To know which request URI to use please read HTTP requests.

1. Select HTTP request PUT/PATCH and enter OData service URL for create in URL field. ( Add key field and its value which is to be updated)
   
2. Provide x-csrf-token parameter in HEADERS (To fetch x-csrf-token refer How to fetch x-csrf-token?).
   
3. Provide the data to be created in the BODY tab and select the relevant data type. Here, we have selected raw.
   
4. Save and click on Send to execute the request.

 

DELETE request

1. Select HTTP request DELETE and enter OData service URL for create in URL field. ( Add key field and its value which is to be deleted)
   
2. Provide x-csrf-token parameter in HEADERS (To fetch x-csrf-token refer How to fetch x-csrf-token?).
   
3. For DELETE requests we don’t have to provide any input in BODY.
   
4. Save and click on Send to execute the request.

Sharing API requests

To share your API requests with your team or other people follow the below steps.

1. Save your requests in Collection.
2. Click on Collection that you want to share.
3. Click on the Share button
   
4. There are three ways you can share.
   

Best practices

1. If a parameter or value is used at multiple places. Always try to create its variable in the Environment section and use the variable in your requests.
   Example: If api.getpostman.com is used in all your requests URL.
   
   Create a variable with value api.getpostman.com and use the variable everywhere.
   The positive aspect is in case your domain is changed, you only need to change the value in one place and all your requests will adapt it.
   
   

 

2. If you are adding Authorization, never provide your password directly in your Request or Collection level.

The mishappening is, if you provide your password directly at a collection level or in request and you share the collection with your team or other people, the password will also get shared with them. So, everyone with that collection will get to know your password.

The best approach is to create a variable for your password in the environment section and use that variable in the password field. This way only the variable name will be shared and your password will be safe.

3. Instead of fetching x-csrf-token value and adding it to request every time manually, you can create a variable for x-csrf-token in the environment and add a script code to automatically update the x-csrf-token value in the environment.