Call an External API and Parse the Response (JSON or XML))

Now, create the Simple Transformation, which converts the XML data to ABAP data.

1. In the Project Explorer, select your package (from the previous tutorial) and choose New > Other ABAP Repository Object > Transformations > Transformation, then choose Next.

   

2. Enter the following:

   • Name: Z_OVERPASS_XML_ST_000
   • Description: Transform Overpass Map Data: XML-ABAP
   • Template: Simple transformation

   

3. Choose your transport request and choose Finish. A skeleton transformation appears in a new editor.

4. Copy the following code into the <tt:transform... node:

   ABAP Copy

   <tt:root name="osm"/>
   
   <tt:template>
     <osm tt:ref=".osm">
       <tt:attribute name="version" value-ref="api_version"/>
       <tt:attribute name="generator" value-ref="api_generator"/>
       <note tt:value-ref="note"/>
       <meta tt:ref="metadata">
         <tt:attribute name="osm_base" value-ref="osm_base"/>
         <tt:attribute name="areas" value-ref="osm_areas"/>
       </meta>
       <tt:loop ref="nodes">
         <node>
           <tt:attribute name="id" value-ref="id"/>
           <tt:attribute name="lat" value-ref="latitude"/>
           <tt:attribute name="lon" value-ref="longitude"/>
           <tt:loop ref="tags">
             <tag>
               <tt:attribute name="k" value-ref="property"/>
               <tt:attribute name="v" value-ref="value"/>
             </tag>
           </tt:loop>
         </node>
       </tt:loop>
     </osm>
   </tt:template>

   Show all 26 lines Show less

   

5. Check your syntax (Ctrl+F2).

6. Format (Ctrl+F1), save (Ctrl+S) and activate (Ctrl+F3) your class.

If you are using JSON, skip this step, since, instead of an ABAP transformation, you use the XCO Library.

To be able to access the external service, you will:

1. Create an HTTP client that points to your communication scenario and service id

2. Configure and send an HTTP request. You configure the request using lo_request->set_query( ) including specifying whether the response should be XML or JSON

3. Convert the response to ABAP structures

4. Output the response in the ABAP console

5. Catch any potential exceptions that may be thrown.

A sample of the raw XML output is available here: OverpassRawOutputXML.txt

Implement the method if_oo_adt_classrun~main by inserting the following code. Replace the 000 with your group number or initials.

```ABAP
" Get data using XML
METHOD if_oo_adt_classrun~main.
  " Create HTTP client
  TRY.
  DATA(lo_destination) = cl_http_destination_provider=>create_by_comm_arrangement(
                           comm_scenario  = 'ZMDC_OVERPASS_CSCEN'
                           service_id     = 'ZMDC_OVERPASS_OBS_REST'
                         ).

  DATA(lo_http_client) = cl_web_http_client_manager=>create_by_http_destination( i_destination = lo_destination ).
  DATA(lo_request) = lo_http_client->get_http_request( ).

  " Send request; store response in lv_xml_results
  lo_request->set_query( query = 'data=area[name="Heidelberg"];node["amenity"="biergarten"](area);out;' ).

  DATA(lo_response) = lo_http_client->execute( i_method = if_web_http_client=>get ).
  DATA(lv_xml_results) = lo_response->get_text( ).

CATCH cx_root INTO DATA(lx_exception).
  out->write( lx_exception->get_text( ) ).
ENDTRY.
" Create structures etc
TYPES:
BEGIN OF ts_tag,
property TYPE string,
value TYPE string,
END OF ts_tag,
BEGIN OF ts_node,
  id        TYPE string,
  latitude  TYPE string,
  longitude TYPE string,
  tags      TYPE STANDARD TABLE OF ts_tag WITH EMPTY KEY,
END OF ts_node,

BEGIN OF ts_metadata,
  osm_base  TYPE string,
  osm_areas TYPE string,
END OF ts_metadata,

BEGIN OF ts_osm,
  api_version   TYPE string,
  api_generator TYPE string,
  note          TYPE string,
  metadata      TYPE ts_metadata,
  nodes         TYPE STANDARD TABLE OF ts_node WITH EMPTY KEY,
END OF ts_osm.
DATA ls_osm TYPE ts_osm.
TRY.
" transform response; store transformed response in structure osm
CALL TRANSFORMATION zmdc_osm_xml_st
SOURCE XML lv_xml_results
RESULT osm = ls_osm.
  out->write( | Names of beer gardens in Heidelberg (Germany) found on OpenStreetMaps. | ).
  out->write( | Data is obtained from the OSM API in XML format and read into ABAP using a simple transformation (ST). | ).
  out->write( | Note: Not all locations have an associated name. | ).
  out->write( | Generator: { ls_osm-api_generator } | ).
  out->write( | ---------------------------------- | ).

  " Output data to console
  DATA lv_index TYPE int4.
  LOOP AT ls_osm-nodes ASSIGNING FIELD-SYMBOL(<node>).
    lv_index = sy-tabix.
    LOOP AT <node>-tags ASSIGNING FIELD-SYMBOL(<tag>).
      IF <tag>-property = 'name'.
        out->write( | Beer garden number { lv_index }: { <tag>-value } | ).
      ENDIF.
    ENDLOOP.
  ENDLOOP.
  out->write( | ---------------------------------- | ).
" catch any error
CATCH cx_root INTO DATA(lx_root).
out->write( lx_root->get_text( ) ).
ENDTRY.
ENDMETHOD.
Code

Copy
</code></pre>
</div>
<div class="tab-panel" data-tab-panel="1" data-tab-name="JSON" hidden>
<p>To be able to access the external service, you must:</p>
<ol>
<li>
<p>Create an HTTP client that points to your communication scenario and service id</p>
</li>
<li>
<p>Configure and send an HTTP request. You configure the request using <code>lo_request-&gt;set_query( )</code> including specifying whether the response should be XML or JSON</p>
</li>
<li>
<p>Convert the response to ABAP structures</p>
</li>
<li>
<p>Output the response in the ABAP console</p>
</li>
<li>
<p>Catch any potential exceptions that may be thrown.</p>
</li>
</ol>
<p>A sample of the raw JSON output is available here:
<a href="https://raw.githubusercontent.com/sap-tutorials/abap-core-development/master/tutorials/abap-environment-external-api/OverpassRawOutputJSON.txt">OverpassRawOutputJSON.txt</a></p>
<p>Implement the method <strong><code>if_oo_adt_classrunmain</code></strong> by inserting the following code. Replace the <code>000</code> with your group number or initials.</p>
<pre><code>```ABAP
&quot; Get data using JSON
METHOD if_oo_adt_classrunmain.
&quot; Create HTTP client; send request
TRY.
DATA(lo_destination) = cl_http_destination_provider=&gt;create_by_comm_arrangement(
comm_scenario  = 'Z_OVERPASS_JSON_CS_000'
service_id     = 'Z_API_OVERPASS_JSON_000_REST'
                     ).

  DATA(lo_http_client) = cl_web_http_client_manager=&amp;gt;create_by_http_destination( i_destination = lo_destination ).
  DATA(lo_request) = lo_http_client-&amp;gt;get_http_request( ).

  lo_request-&amp;gt;set_query( query = &#39;data=[out:json];area[name=&amp;quot;Heidelberg&amp;quot;];node[&amp;quot;amenity&amp;quot;=&amp;quot;biergarten&amp;quot;](area);out;&#39; ).

  DATA(lo_response) = lo_http_client-&amp;gt;execute( i_method = if_web_http_client=&amp;gt;get ).
  DATA(lv_json_results) = lo_response-&amp;gt;get_text( ).

CATCH cx_root INTO DATA(lx_exception).
  out-&amp;gt;write( lx_exception-&amp;gt;get_text( ) ).
ENDTRY.
&quot; Create an ABAP structure to contain the data from the API
TYPES:
BEGIN OF ts_tags,
name TYPE string,
website TYPE string,
END OF ts_tags,
BEGIN OF ts_element,
  type TYPE string,
  id   TYPE string,
  lat  TYPE string,
  lon  TYPE string,
  tags TYPE ts_tags,
END OF ts_element,

BEGIN OF ts_osm3s,
  timestamp_osm_base  TYPE string,
  timestamp_areas_base TYPE string,
  copyright TYPE string,
END OF ts_osm3s,

BEGIN OF ts_osm,
  version   TYPE string,
  generator TYPE string,
  osm3s     TYPE ts_osm3s,
  elements  TYPE STANDARD TABLE OF ts_element WITH EMPTY KEY,
END OF ts_osm.
DATA ls_osm TYPE ts_osm.
&quot; Convert the data from JSON to ABAP using the XCO Library; output the data
TRY.
  xco_cp_json=&amp;gt;data-&amp;gt;from_string( lv_json_results )-&amp;gt;apply( VALUE #(
    ( xco_cp_json=&amp;gt;transformation-&amp;gt;pascal_case_to_underscore )
    ( xco_cp_json=&amp;gt;transformation-&amp;gt;boolean_to_abap_bool )
  ) )-&amp;gt;write_to( REF #( ls_osm ) ).

  out-&amp;gt;write( | Names of beer gardens in Heidelberg (Germany) found on OpenStreetMaps. | ).
  out-&amp;gt;write( | Data is obtained from the OSM API in JSON format and read into ABAP using the XCO library. | ).
  out-&amp;gt;write( | Note: Not all locations have an associated name. | ).
  out-&amp;gt;write( | Generator: { ls_osm-generator } | ).
  out-&amp;gt;write( | ---------------------------------- | ).

  LOOP AT ls_osm-elements ASSIGNING FIELD-SYMBOL(&amp;lt;element&amp;gt;).
    out-&amp;gt;write( | Beer garden number { sy-tabix }: { &amp;lt;element&amp;gt;-tags-name } | ).
  ENDLOOP.
  out-&amp;gt;write( | ---------------------------------- | ).

&amp;quot; catch any error
CATCH cx_root INTO DATA(lx_root).
  out-&amp;gt;write( lx_root-&amp;gt;get_text( ) ).
ENDTRY.
ENDMETHOD.

Show all 108 lines
Show less