GoCoding.org

DocuSign Integration in SAP UI5, Node.js and SAP ABAP

by | Jun 12, 2021 | UI5 Integrations

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”

DocuSign Settings

DocuSign Apps and Keys

Step 03: Save the following

DocuSign Credentials
Now we have aud, Account_ID and API_URI.

Step 04: Add App and Integration Key

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

DocuSign get Integration Key

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

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

DocuSign get Secret Key

Here we have generated Secret.

Step 06: Generate RSA
Now generate RSA:

DocuSign generate RSA

This will generate Public and Private Key:

DocuSign get 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:

DocuSign 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.

DocuSign Create Template

3. Enable PowerForm option on that template:

DocuSign Enable Powerforms

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:
DocuSign Postman open Environment

And add all the details that we have created above:

DocuSign Postman set Environment

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:

DocuSign Postman set JWT

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.

Get Unix timestamp

Using above details will generated the token:

Generate JWT

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

DocuSign Postman set Authorization Bearer

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

Generate Encoded Bearer

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):

DocuSign get Consent

Go to your DocuSign account and convert your grant to implicit:

DocuSign change Grant

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

DocuSign Postman generate token

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

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

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:

Create an Envelope expected output

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

Postman to create an Envelope with a pdf document and send it to a user

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

  1. 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

Get a URL based upon the above Envelope

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:

Get a URL based upon the above Envelope Expected Output

This link can be embedded anywhere as per requirement.

Preview DocuSign in Website

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

Postman to Get a URL based upon the above Envelope

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

  1. 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

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

Status before signing the document:

Output of the status of the envelope

Status after signing the document:

Status after signing a document

Same can be called via Postman as shown below:

Postman to sign a document in DocuSign

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):

Troubleshoot errors

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

ErrorReasonSolution
Invalid authentication requestHere you will get more reason of this error.

 

If the error is “The response type is not supported”

Then

response_type value should be set as code

Token type mismatchIt means the provided token type is wrong·         Use correct type of token with correct payload:

1.       Response Type: This can be response_type=code (for Authorization Code Grant  and JWT Grant) or response_type=token (for Implicit Grant)

2.       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

Expired Client tokenIt means you access token has expired·         Refresh or generate a new access token
Client ID is disabledIt means your app on DocuSign developer account is disabled·         Activate your App on DocuSign developer portal
Invalid user site IDIt means that the URL used for generating the access token and performing DocuSign operations are not same·         Use the same URI for all the operations
Issuer not foundIt means the User is invalid·         Make sure the User has access to the DocuSign developer account that is being used to perform operations
User not foundIt means the User is invalid·         Make sure the User has access to the DocuSign developer account that is being used to perform operations
Refresh token mismatchIt means the token has either expired or it is wrong·         Regenerate access or refresh token
Bad RequestIt occurs mainly due to wrong authentication URI·         For the developer demo environment, you should use URIs from the https://account-d.docusign.com/oauth domain.

·         For the production platform, you should use URIs from the https://account.docusign.com/oauth domain.

 

Invalid authentication request: The response type is not supported.It means authorization code request is not set to code.·         Set response_type as code
Invalid GrantEither the authorization code is incomplete or expired.·         You can regenerate the Authorization Code

·         You can check if the authorization code provided is correct and no extra white spaces are added in that

Invalid RedirectUriIt means the redirect URI that is maintained within DocuSign Integration key is not the one being sent via payload.·         Use the same redirect URI that you maintain within your DocuSign Integration Key
Consent_requiredFor the very first time, you need to provide consent manually, if not then you will get this error·         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
Page cannot be displayed after requesting the codeIt means the redirect URI is not a valid webpage·         Maintain a valid URI as redirect URI within the Integration Key at DocuSign
invalid_grant: no_valid_keys_or_signaturesIt means something is wrong in JWT assertion. It can be either in private key, missing exp, invalid aud,·         Refer to the Prerequisite section of this article and provide right values as mentioned there
Partner Authentication Failure / Integration key disabledIt means your app on DocuSign developer account is disabled·         Activate your App on DocuSign developer portal
CORS: Cross OriginYou might be using the APIs directly in your AJAX calls.You need to have it integrated via backend or via a destination.
ONESIGNALLSIGN_NOT_SATISFIEDFreeform signing is not allowed for your account because it conflicts with other settings, please place signing tabs for each signer..Go to Admin setting in DocuSign, under senders settings, switch the drop down for “Document Visibility” as off

Reference Links

You can explore more here:

0 Comments

Submit a Comment

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Advertisement

Advertisement

Advertisement

Advertisement