Preface – This post is part of the UI5 Integration Programs series.

Introduction

DocuSign is a cloud based software (SaaS) to electronically sign (eSign) your agreements and documents. It is accessed via browser based access or via its Android and iOS apps. It provides APIs and SDKs to integrate and embed its services to your Apps and websites. In this article, we will

Prerequisite

Before we start with integration, it is mandatory to have a DocuSign account, SAP Cloud Platform (for Open Connector and Cloud based Integration only), SAP Open Connector Access (for open connector Integration only).

Once you have created a DocuSign account successfully, get the following details from the developer account (steps discussed later – DocuSign API Provider Setup):

• iss: This is integration key or Client ID
• sub: This is User ID
• aud: account-d.docusign.com (for demo environment) and account.docusign.com (for production environment)
• scope: This will be signature (for Authorization Code Grant and Implicit Grant) or signature impersonation (for JWT)
• iat: This is the unix time from when your oAuth will be valid
• exp: This is the unix time until when your oAuth will be valid
• Public Key, Private Key: These are the keys generated on the platform
• Response Type: This can be response_type=code (for Authorization Code Grant and JWT Grant) or response_type=token (for Implicit Grant)
• Grant Type: This can be grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer (for JWT Grant) or grant_type=authorization_code (for Authorization Code Grant). It is not required for Implicit Grant
• API_URI: This can be https://demo.docusign.net (for Demo Developer Account), https://account-d.docusign.com (for Developer Account) or https://account.docusign.com (for Production Account)
• Secret: This is the secret key
• Redirect URI: This is the URI, where your user will be sent once they complete the eSigning. This has to be maintained in your DocuSign Account
• Link for getting consent for the very first time:
  https://account-d.docusign.com/oauth/auth?
  response_type=code
  &scope=YOUR_REQUESTED_SCOPES
  &client_id=YOUR_INTEGRATION_KEY
  &redirect_uri=YOUR_REDIRECT_URI
• Account_ID: This is API Account ID

We will save all the above details in a local file so that it will be easy for us to provide whenever and wherever required in later steps.

Types of DocuSign Integrations

There are thousands of scenarios where you can plan to have your document/agreements signed by a user. To get it signed, you need to either send the document to that user via an email or get that user at your platform to get the document signed there itself. Thus we will discuss these two scenarios in brief:

·         To Send a mail from UI for document signing

In this scenario, you can either

1. Visit DocuSign platform, upload the document and send it to a particular email ID
2. Integrate the DocuSign to your UI in such a way that you pass document, subject of mail and mail content with required user’s email IDs via API. This API will therefore trigger a mail. Then you can retrieve the status of the document signature and update the same in your UI.

·         To get the document signed from UI

In this scenario, you can either

1. Visit DocuSign platform, upload the document and get a link for integration. You can use this link directly in the UI (via iframe) and then user can click and sign using the link. This scenario is valid only in a use case where same document is signed by every user i.e. the document remains same for all the user. e.g. A document related to the security of the office that can be signed by every visitor.
2. Integrate the DocuSign to your UI in such a way that you pass document, subject of mail and mail content with required user’s email IDs via API. This API will therefore trigger a mail as well as return a signing URL. Then you can integrate this URL and the user can sign the document via UI. Thereafter retrieve the status of the document signature and update the same in your UI.

DocuSign API Provider Setup

Step 01: Sign into DocuSign Developer Account: Visit here and login with your credentials.

Step 02: Go to Settings and click “Apps and Keys”

Step 03: Save the following

Now we have aud, Account_ID and API_URI.

Step 04: Add App and Integration Key

This will ask for your App name, here we will give it “Test”. It will navigate to next page.

And you can get your Integration Key (or iss).

Step 05: Generate Secret Keys
Now generate and save your key:

Here we have generated Secret.

Step 06: Generate RSA
Now generate RSA:

This will generate Public and Private Key:

Save these keys. Remember the starting (—–BEGIN PUBLIC KEY—–) and ending part (—–END PUBLIC KEY—–) of both the keys are important and should be always copied and used with the keys. Without these parts, the keys are invalid.

Step 07: Add a Redirect URI
Now add a redirect URI:

This can be any link that you want your users to see once they are done with signing.

Step 08: Save the changes
Now we have gathered all the information required for integration, you need to save them all something like this:

{
iss: 9a5a2a7a-5f25-4526-bc62-82dc62fae2b1
sub: 0211f444-eab3-4b75-ce7c-8b95adf890
aud: account-d.docusign.com
Public Key, Private Key: These are the keys generated on the platform
API_URI: https://demo.docusign.net
Secret: f2e1c847-bdc3-48da-a444-603f228988de
Redirect URI: https://www.docusign.com/
Account_ID: 92222dc4-6430-44c6-81c9-0742c14f82f5
}

Different Types of DocuSign Integration

1.      Direct Integration using iframe: PowerForms

This is the simplest integration option. This is only valid for the use case where document remains same for all the users.
1. Go to your account
2. Create a Template: Upload your document and add the place where you want signature.

3. Enable PowerForm option on that template:

As you can see above, a URL is generated. This URL can be integrated in your website using the concept of iframe or sent directly to the users via email and sms. This feature is not available for Demo accounts.
The status of the signatures will be available on DocuSign platform only.

2.      Postman Testing of DocuSign

Many developers want to try the DocuSign via Postman before they jump into actual development and integration. You can find the setup of the postman for DocuSign here and also download the postman collection. Apart from this, you can directly access the cloud version of postman with preloaded collection here.
In both scenario, setup the environment:

And add all the details that we have created above [We have not added, as we directly change values in the URL, you can too ignore this]

Now the very next step for us will be to generate an Authorization key so that it can be used to perform all other operations. Here we will be generating a token key based upon JWT Authorization method because same method we will be using for Integration using Rest APIs in UI5, Node.js as well as ABAP.
For JWT token, postman call looks like this:

As you can see, we need to pass assertion value here.

To generate an assertion, we need to create a JWT token. It can be created here. Change the algorithm type as RS256, in verify signature enter the Public and Private keys that we have generated earlier, and in Payload enter an object like this:

{
  "iss": "<we have generated above> ",
  "sub": ""<we have generated above> ",
  "aud": "account-d.docusign.com",
  "iat": <Get current unix time e.g. 1623513795>,
  "exp": <Get 1 hour delayed unix time>,
  "scope": "signature impersonation"
}

To get the unix time, visit here.

Using above details as well as change Public & Private key below, and then it will generated the token:

Now copy and paste it in assertion in postman.
And then, under Headers tab we need to add a bearer token:

You can simply convert your integratiokey:secret as base 64 or generate here

After this one more important step is left, else you will “consent_required” error. We need to take consent using the below link:
https://account-d.docusign.com/oauth/auth?
response_type=code
&scope=YOUR_REQUESTED_SCOPES
&client_id=YOUR_INTEGRATION_KEY
&redirect_uri=YOUR_REDIRECT_URI

For our use case, it will be: https://account-d.docusign.com/oauth/auth?response_type=code&scope=signature impersonation&client_id=9a5a2a7a-5f25-4526-bc62-82dc62fae2b1&redirect_uri=https://www.docusign.com/

It will ask you to provide consent (after logging in):

Note: For Prod version, do the below [Grant change to Implicit] and again grant access via the link that we created earlier, in our case: https://account-d.docusign.com/oauth/auth?response_type=code&scope=signature impersonation&client_id=9a5a2a7a-5f25-4526-bc62-82dc62fae2b1&redirect_uri=https://www.docusign.com/

Go to your DocuSign account and convert your grant to implicit [Do not change for Postman testing]:

And now we are all set to receive our Authentication token from DocuSign.

Once you get the Authorization, you can use the same to perform all other operations. Now we will be performing the following operations in postman:

1. Create an Envelope with a pdf document and send it to a user

To get an Envelope with a pdf document, we will need to upload that pdf and provide user details (email ID and name). This will create an envelope in DocuSign and trigger a mail to the user. In case, you just want to send a mail to the user then you can skip the next step.
Before you try in postman, try in DocuSign Swagger API as shown below:
POST /v2.1/accounts/{accountId}/envelopes

Here we have provided following test data under parameters:

{
  "documents": [
    {
      "documentBase64": "<Base64BytesHere>",
      "documentId": "1",
      "name": "test"
    }
  ],
  "emailSubject": "test",
  "recipients": {
    "signers": [
      {
        "clientUserId": "test",
        "email": "test@test.com",
        "name": "test",
        "recipientId": "1"
      }
    ]
  },
  "status": "sent"
}

The above data created an envelope as shown below:

Now in postman, first get the access token as we did earlier and then open “Create an Envelope” API within collection as shown below at given URI and above payload: POST https://demo.docusign.net/restapi/v2.1/accounts/<Your_Account_ID>/envelopes

Now, it will too generate an envelope as the swagger API did.

2. Get a URL based upon the above Envelope

In case, you want the user to sign the document via browser, then you will have to generate a signing url. This url can be then integrate in an iFrame. For that purpose, you need to retain the envelopeId generated above i.e. “4098ec03-461f-4081-b0d8-ac59618bfc1a”.

Now, we will try generating first via DocuSign Swagger API:

POST /v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient

The JSON for above:

As shown above, we clicked on createRecipient, entered our accoundId, envelopId, a return url (where user will be redirected after signing). This will generate a link as shown below:

This link can be embedded anywhere as per requirement.

In postman, first get the access token as we did earlier and create a new request as shown below:

This will too generate a link as above which can be embedded wherever required.

3. Get status of the envelope to check if the user has signed the document or not

Now, we are at the last stage where a user has already signed a document and we want to know the status. Go to DocuSign Swagger API, and click get within Envelopes, provide accountId and envelopeId to get the status as shown below:

GET /v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients

Status before signing the document:

Status after signing the document:

Same can be called via Postman as shown below:

These same above three steps will be used in all next integrations types.

3.      Integration using Open Connector

This use case is covered here: https://blogs.sap.com/2019/07/22/digital-signatures-in-sapui5-using-docusign-and-openconnectors/

In this particular use case, remember we need to authenticate and that is covered here: https://blogs.sap.com/2019/03/13/cloud-integration-how-to-create-a-sample-integration-scenario-using-open-connectors-adapter/

In case readers want this use case and are not able to implement it out, then let us know in the comment section, we will try to cover that in a separate article.

4.      Integration using DocuSign Rest APIs in UI5

We can directly use the Rest APIs provided by DocuSign to integrate it in our UI5 Application. We have already used them to test in step 02. Here, I will mention them once again with AJAX calls. The Authorization and assertion part is explained in initial part of the article.

Step 01: Get JWT Authentication token

var settings = {

  "url": "https://account-d.docusign.com/oauth/token",

  "method": "POST",

  "timeout": 0,

  "headers": {

    "Authorization": "Basic OWE1YTJhN2EtNWYyNS00NTI2LWJjNjItODJkYzYyZmFlMmIxOjI0NDllNTdhLThiNjYtNDZlOC1hOTRjLTdlMjZlYzUyN2E5Yw==",

    "Content-Type": "application/x-www-form-urlencoded"

  },

  "data": {

    "assertion": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiI5YTVhMmE3YS01ZjI1LTQ1MjYtYmM2Mi04MmRjNjJmYWUyYjEiLCJzdWIiOiIwMjExZjQzMy1lYWEzLTRkNzMtYmU3Yi04Yjk1YWRmYzRlMDgiLCJhdWQiOiJhY2NvdW50LWQuZG9jdXNpZ24uY29tIiwiaWF0IjoxNjIzNTE3MTA5LCJleHAiOjE2MjM1MjA3MjQsInNjb3BlIjoic2lnbmF0dXJlIGltcGVyc29uYXRpb24ifQ.EqpyIrpytjyMX6xZqRsfgxMyRq2gkhotmAM8kUbtgJ83FK0dbolZ-gEtixckUIeAQvbb-gk5KV6_kwsWs0CgO-waxWtV3XV8k8jXPW42UxQXT1zBVwCm8TjzYpSvIdOGJKGGaPzMj9qJN8a2SSVB2FwkqoMgprEvnWESY3RjT-hzAYbqh5KdiLoFj_EO6KbVS8IUsusXtUYm10YFFduhJ0xN90m50wku0ChijQxKZNyDPai5v-C4NBuhlQA58RqB8OKq4B9WDSnyYHP87R8TaAoqAv8fsLZe8TtOM4J8ZAVG_CJQiKGJOabtFsW1zgNCTr8KCZvL5t6gEJg2t_vx4g",

    "grant_type": "urn:ietf:params:oauth:grant-type:jwt-bearer"

  }

};

$.ajax(settings).done(function (response) {
  console.log(response);
});

Use the response in step 01, and get the token that will be passed in step 02, step 03 and step 04.

Step 02: Create an Envelope with a pdf document and send it to a user

var settings = {

  "url": "https://demo.docusign.net/restapi/v2.1/accounts/<account ID>/envelopes ",

  "method": "POST",

  "timeout": 0,

  "headers": {

    "Accept": "application/json",

    "Authorization": "Basic OWE1YTJhN2EtNWYyNS00NTI2LWJjNjItODJkYzYyZmFlMmIxOjI0NDllNTdhLThiNjYtNDZlOC1hOTRjLTdlMjZlYzUyN2E5Yw==",

    "Content-Type": "text/plain"

  },

  "data": "{\n  \"documents\": [\n    {\n      \"documentBase64\": \"<Base64BytesHere>\",\n      \"documentId\": \"1\",\n      \"name\": \"test\"\n    }\n  ],\n  \"emailSubject\": \"Test\",\n  \"recipients\": {\n    \"signers\": [\n      {\n        \"clientUserId\": \"1\",\n        \"email\": \"rudanboss@gmail.com\",\n        \"name\": \"Rudra\",\n        \"recipientId\": \"1\"\n      }\n    ]\n  },\n  \"status\": \"sent\"\n}",

};




$.ajax(settings).done(function (response) {

  console.log(response);

});

The envelope ID will be received in response and will be used in step 03 and step 04.

Step 03: Get a URL based upon the above Envelope

var settings = {

  "url": "https://demo.docusign.net/restapi/v2.1/accounts/<account ID>/envelopes/<envelop ID>/views/recipient",

  "method": "POST",

  "timeout": 0,

  "headers": {

    "Accept": "application/json",

    "Authorization": "Basic OWE1YTJhN2EtNWYyNS00NTI2LWJjNjItODJkYzYyZmFlMmIxOjI0NDllNTdhLThiNjYtNDZlOC1hOTRjLTdlMjZlYzUyN2E5Yw==",

    "Content-Type": "text/plain"

  },

  "data": "{\r\n  \"authenticationMethod\": \"None\",\r\n  \"clientUserId\": \"test\",\r\n  \"email\": \"test@test.com\",\r\n  \"recipientId\": \"1\",\r\n  \"returnUrl\": \"https://www.docusign.com/\",\r\n  \"userName\": \"test\"\r\n}   ",

};




$.ajax(settings).done(function (response) {

  console.log(response);

});

In the response we will get an URL, this URL can be embedded in an iframe or via a new tab in browser.

Step 04: Get status of the envelope to check if the user has signed the document or not

var settings = {

  "url": "https://demo.docusign.net/restapi/v2.1/accounts/<Account ID>/envelopes/<Envelope ID>/recipients",

  "method": "GET",

  "timeout": 0,

  "headers": {

    "Authorization": "Basic OWE1YTJhN2EtNWYyNS00NTI2LWJjNjItODJkYzYyZmFlMmIxOjI0NDllNTdhLThiNjYtNDZlOC1hOTRjLTdlMjZlYzUyN2E5Yw=="

  },

};


$.ajax(settings).done(function (response) {

  console.log(response);

});

In the response we will get the status of the envelope. In case it is completed, then the user has completed the document signing.

5.      Integration using Node.js packages

For the security purpose, it would be good to implement all the calls in backend via Node.Js such that the UI only gets the final URL that can be embedded via iframe and signed by the user. Here we will just show you how to get DocuSign authentication token via Node.Js, also we have used the concept of destination here, that is actually a place in SAP Cloud Foundry to maintain APIs to make calls secure. That part can be ignored and directly second function of the node can be used with hard coded values in case you are not using SAP environment.

For this purpose we will need the following node packages:

"moment": "^2.24.0",
 "jsonwebtoken": "^8.5.1"

Node.Js functions to get Authentication token for DocuSign:

               const  moment = require('moment')

    , jwt = require('jsonwebtoken');

                /**

                 ** Get Access details from Destination and then pass it to next function docusignAccessToken

                 ** @in: GET call

                 ** @out: Response Success - Auth_Token

                 */

                getDocusignAuthDetails() {

                return new Promise(async (resolve, reject) => {

                try {
                let destUri, tokenUrl, clientId, clientSecret;
                clientId = <Your Client ID>; "Client ID of Destination in SAP Cloud Foundry
                clientSecret = <Your Client Secret>; "Client Secret of Destination in SAP Cloud Foundry
                tokenUrl = `<Your Token URL>`; "URL to get the token, this is saved on Destination in SAP Cloud Foundry
                destUri = <Your Destination URL>; "URL of Destination in SAP Cloud Foundry that contains the actual URL of DocuSign, for security purpose
 let options = {
 uri: tokenUrl,
 method: 'GET',
 headers: {
 'content-type': 'application/json',
 "Authorization": "Basic " + Buffer.from(clientId + ":" + clientSecret).toString("base64"),
}

};



 let tokenResp = await httpHandler.execPOSTReq(options);
 tokenResp = JSON.parse(tokenResp);
 // Here we are calling SAP Cloud Foundry Destination to get the access_token, this can be replaced by a simple HTTP call too

  options = {
  uri: destUri + '/destination-configuration/v1/destinations/docusign_get_token',
  method: 'GET',
 headers: {
 'content-type': 'application/json',
 Authorization: 'bearer ' + tokenResp.access_token
  }
 };


  let destConfig = await httpHandler.execPOSTReq(options);
 destConfig = JSON.parse(destConfig).destinationConfiguration;
  resolve(destConfig);
} catch (err) {
 console.log(err);
 reject(err)
  }
})
 },

  /**

 ** Get Access Token for docusign

  ** @in: POST call

  ** @out: Response Success - Auth_Token
  */

 async docusignAccessToken(req, res) {
  try {
 var authCreds = await self.getDocusignAuthDetails();
 let privateKEY = Buffer.from(authCreds.RSA_pvt_key, 'base64');
// Step 1. Create a JWT token for DocuSign
 const now = moment(),
 iat = now.unix(),
  exp = now.add((9 * 60) + 30, 's').unix();
 // this is already explained in initial part of the article
 const ghJWT =
jwt.sign({
 "iss": authCreds.clientId,
 "sub": authCreds.sub,
 "aud": authCreds.aud,
 "scope": authCreds.scope,
 "iat": iat,
 "exp": exp
 },
 privateKEY, {
 algorithm: 'RS256'
  });
 var request = require('request');
var options = {
'method': 'POST',
 'url': authCreds.URL,
'headers': {
 "Authorization": "Basic " + Buffer.from(authCreds.clientId + ":" + authCreds.clientSecret).toString("base64"),
 'Content-Type': 'application/x-www-form-urlencoded'
  },
 form: {
 'assertion': ghJWT,
 'grant_type': 'urn:ietf:params:oauth:grant-type:jwt-bearer'
}
 };

  request(options, function (error, response) {
  if (error) throw new Error(error);
  console.log(response.body);
  res.status(200).send({ //Success response contains Access token of DocuSign
 status: true,
 message: response.body
 });
 });

} catch (err) {
 errorMethods.handleError(err, res, req, 'ErrDocusignAccessToken');
 }
 }

6.      Integration using ABAP

You can follow the steps given in Step 02 and convert them in ABAP API calls.

An example to create token is shown below, replace them with valid keys and values:

  METHOD get_token.
    DATA: lo_http_client TYPE REF TO if_http_client.
    DATA: response TYPE string,
          lv_url   TYPE string.
    CONSTANTS: lv_initial_url TYPE string VALUE '<URL>',
               lv_auth        TYPE string VALUE '<Bearer Auth code>'.
    "create HTTP client by url
    CALL METHOD cl_http_client=>create_by_url
      EXPORTING
        url                = lv_initial_url
      IMPORTING
        client             = lo_http_client
      EXCEPTIONS
        argument_not_found = 1
        plugin_not_active  = 2
        internal_error     = 3
        OTHERS             = 4.

    "Available API Endpoints

    IF sy-subrc <> 0.

      "error handling

    ENDIF.

    "setting request method

    lo_http_client->request->set_method('GET').

    "adding headers

    lo_http_client->request->set_header_field( name = 'Authorization' value = lv_auth ).

    "Available Security Schemes for productive API Endpoints

    "OAuth 2.0

    CALL METHOD lo_http_client->send

      EXCEPTIONS

        http_communication_failure = 1

        http_invalid_state         = 2

        http_processing_failed     = 3

        http_invalid_timeout       = 4

        OTHERS                     = 5.

    IF sy-subrc = 0.

      CALL METHOD lo_http_client->receive

        EXCEPTIONS

          http_communication_failure = 1

          http_invalid_state         = 2

          http_processing_failed     = 3

          OTHERS                     = 5.

    ENDIF.
    IF sy-subrc <> 0.

      "error handling

    ENDIF.
    response = lo_http_client->response->get_cdata( ).
   GV_TOKEN = response.

  ENDMETHOD.

Using the above GV_TOKEN we will get the keys and this key can be passed in other required GET/POST calls.

An example of GET/POST call in ABAP is shown below:
  METHOD get_proof_history.
    DATA: lo_http_client TYPE REF TO if_http_client.

    DATA: response TYPE string,

          lv_url   TYPE string,

          lv_auth  TYPE string,

          lv_auth2 TYPE string.

    CONSTANTS : lv_initial_url TYPE string VALUE '<URL>'.
    IF iv_object_id IS NOT INITIAL.

*** Getting Token

      TYPES:

        BEGIN OF t_entry,

          access_token TYPE string,

          token_type   TYPE string,

          expires_in   TYPE n LENGTH 8,

          scope        TYPE string,

          jti          TYPE string,

        END OF t_entry .

      TYPES:

        t_entry_map TYPE SORTED TABLE OF t_entry WITH UNIQUE KEY access_token.

      DATA: m_entries TYPE t_entry.

      DATA: lr_instance  TYPE REF TO  /ui5/cl_json_parser.

      CREATE OBJECT lr_instance.

      CALL METHOD me->get_token.

      IF gv_token IS NOT INITIAL.

*        data: itab TYPE TABLE OF string.

*        data: access_tok type string.

*        SPLIT gv_token at '"' INTO TABLE itab.

*        try.

*            lv_auth2 = itab[ 4 ].

*          catch cx_sy_itab_line_not_found.

*        ENDTRY.

        /ui2/cl_json=>deserialize(

        EXPORTING json = gv_token pretty_name = /ui2/cl_json=>pretty_mode-camel_case CHANGING data = m_entries ).

        lv_auth2 = m_entries-access_token.

        gv_token = gv_token+17.

        CONCATENATE 'Bearer' lv_auth2 INTO lv_auth SEPARATED BY space.

      ENDIF.

      DATA lv_object_id TYPE string.

      lv_object_id = iv_object_id.

      TRANSLATE lv_object_id TO LOWER CASE.

      CONCATENATE lv_initial_url lv_object_id INTO lv_url. "Appending Fix URL and the Object ID to get the Request URL

      "create HTTP client by url

      CALL METHOD cl_http_client=>create_by_url

        EXPORTING

          url                = lv_url

        IMPORTING

          client             = lo_http_client

        EXCEPTIONS

          argument_not_found = 1

          plugin_not_active  = 2

          internal_error     = 3

          OTHERS             = 4.

      "Available API Endpoints

      "https://blockchain-service.cfapps.sap.hana.ondemand.com/blockchain/proofOfHistory/api/v1

      "https://blockchain-service.cfapps.eu10.hana.ondemand.com/blockchain/proofOfHistory/api/v1

      "https://blockchain-service.cfapps.us10.hana.ondemand.com/blockchain/proofOfHistory/api/v1
      IF sy-subrc <> 0.

        "error handling

      ENDIF.
      "setting request method, here you can do POST or GET calls

      lo_http_client->request->set_method('GET').

      "creatung Auth value

*       lv_auth2 = 'Basic <URL>'.

      "adding headers

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

      lo_http_client->request->set_header_field( name = 'Accept' value = 'application/json' ).

      lo_http_client->request->set_header_field( name = 'Authorization' value = lv_auth ).

*      lo_http_client->request->set_header_field( name = 'APIKey' value = 'zBoCpDtkaT9jexRjtMk0J98Rs8izmQi1' ).
      "Available Security Schemes for productive API Endpoints

      "OAuth 2.0

      CALL METHOD lo_http_client->send

        EXCEPTIONS

          http_communication_failure = 1

          http_invalid_state         = 2

          http_processing_failed     = 3

          http_invalid_timeout       = 4

          OTHERS                     = 5.
      IF sy-subrc = 0.
        CALL METHOD lo_http_client->receive

          EXCEPTIONS

            http_communication_failure = 1

            http_invalid_state         = 2

            http_processing_failed     = 3

            OTHERS                     = 5.
      ENDIF.
      IF sy-subrc = 1.
        "error handling
        ev_response = 'http_communication_failure'.
      ELSEIF sy-subrc = 2.
        ev_response = 'http_invalid_state'.
      ELSEIF sy-subrc = 3.
        ev_response = 'http_processing_failed'.
      ELSEIF sy-subrc = 0.
        response = lo_http_client->response->get_cdata( ).

*WRITE: 'response: ', response.
        ev_response = response.
      ELSE.
        ev_response = 'Unknown Error'.
      ENDIF.
    ENDIF.
  ENDMETHOD.

7.      Other Integration Options

Apart from the integrations that we have discussed above, there are other types of integrations too that is supported by DocuSign. These are (with GitHub/reference links):

• Android Integration
• iOS Integration
• React Native Integration
• Salesforce Integration
• Dedicated SAP Solution for DocuSign Integration

Troubleshoot errors

While performing the above operations, you can face following issues:

Reference Links

You can explore more here:

• Swagger APIs for DocuSign: Test APIs that can be tested once you login
• Developers Guide: Read all the possible ways of Integrations here