event notification of envelope in DocuSign restapi c#,webapi - docusignapi

I have added event notification at the time of envelope creation in EnvelopeCreate Method as
apiClient.Configuration.DefaultHeader.Add("Authorization", "Bearer " + AccessToken);
EnvelopesApi envelopesApi = new EnvelopesApi(apiClient);
EnvelopeSummary results = envelopesApi.CreateEnvelope(AccountId, env);
EventNotificationForEnvelope();
and EventNotificationForEnvelope method is as
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
EnvelopeDefinition envelopeDefinition = new EnvelopeDefinition();
var eventNotification = new EventNotification();
// Set up the endpoint URL to call (it must be using HTTPS and at least TLS1.1 or higher)
eventNotification.Url = "https:\\testapi.example.com/api/DocuSignEventNotification";
// DocuSign will retry on failure if this is set
eventNotification.RequireAcknowledgment = "true";
// This would send the documents together with the event to the endpoint
eventNotification.IncludeDocuments = "true";
// Allows you to see this in the DocuSign Admin Connect logs section
eventNotification.LoggingEnabled = "true";
var envelopeEvents = new List<EnvelopeEvent>();
// In this case we only add a single envelope event, when the envelope is completed. You can also add events for recipients
envelopeEvents.Add(new EnvelopeEvent { EnvelopeEventStatusCode = "completed",
IncludeDocuments = "true" });
eventNotification.EnvelopeEvents = envelopeEvents;
envelopeDefinition.EventNotification = eventNotification;
and in my api's controller as
public class DocuSignEventNotificationController : ApiController
{
[HttpPost]
[HttpGet]
public HttpResponseMessage DocuSignDocumentStatus(HttpResponseMessage responseMessage)
{
dynamic response = responseMessage.Content.ReadAsStringAsync();
//here I will read values from response and use in my application
return Request.CreateResponse(HttpStatusCode.OK, "Testing");
}
}
I am not getting any response on envelope create and when status is updating of that envelope

A couple of things.
First,
https:\testapi.example.com/api/DocuSignEventNotification
Is not where you have your server I presume. Make sure that you use https and that your server is configured correctly to accepts TLS (1.2 and above).
Using a cloud service or some other third-party instead of building your own is much easier. If you do use your own, you may need to ensure firewall etc. allow for requests coming from the internet.
Second,
There's a log that you can find in the Connect section settings area in the DocuSign web app that can show you all attempts to reach servers. That can help you figure out if the request was made correctly to DocuSign and if DocuSign attempted to call your server and if so - what error may have been returned.
Just click "Logs":

Related

Envelope is not configured for support of recipient signing providers

I am trying to send an envelope to be signed via digital certificate, I am receiving the following message.
com.docusign.esign.client.ApiException: Error while requesting server, received a non successful HTTP code 400 with response Body:
{
"errorCode":"SIGNATURE_PROVIDER_INVALID_FOR_NONSBS",
"message":"Signature providers are not valid for this recipient. Standards Based Signatures must be enabled for the sending account. Envelope is not configured for support of recipient signing providers"
}
Here is code:
private EnvelopeDefinition makeEnvelope(WorkArguments args, Object resumo) throws IOException {
Tabs signerTabs = EnvelopeHelpers.createSignerTabs(EnvelopeHelpers.createSignHere("**signature_1**", ANCHOR_OFFSET_Y, ANCHOR_OFFSET_X));
Signer signer = new Signer();
signer.setEmail(resumo.getMail();
signer.setName(resumo.getName());
signer.setRecipientId("1");
signer.setRoutingOrder("1");
signer.setTabs(signerTabs);
RecipientSignatureProvider provider = new RecipientSignatureProvider();
// provider.setSignatureProviderName("UniversalSignaturePen_ICP_SmartCard_TSP");
provider.setSignatureProviderName("UniversalSignaturePen_ImageOnly");
List<RecipientSignatureProvider> lstProvider = new ArrayList<RecipientSignatureProvider>();
lstProvider.add(provider);
signer.setRecipientSignatureProviders(lstProvider);
EnvelopeDefinition envelope = new EnvelopeDefinition();
envelope.setEmailSubject("Email Test");
envelope.setDocuments(Arrays.asList(EnvelopeHelpers.createDocumentFromFile(resumo.getDirRel(), resumo.getDisplayName(),"1")));
envelope.setRecipients(EnvelopeHelpers.createRecipients(signer));
envelope.setStatus(EnvelopeHelpers.ENVELOPE_STATUS_SENT);
return envelope;
}
The error is caused by a missing/not enabled plan feature. You will need to contact sales team and check with them if SBS - Standard Based Signature is included in your plan

Docusign embedded signing request from template with nodejs

I am using the nodejs docusign api and am having trouble figuring out how do embedded signing request from template. I kinda want it working the way the example does for non template usage.
The main issue i am having is with the way the nodejs docusign library handles recipientIds when you are using a template, cant set the recipientIds directly when you use the template and doesnt seem to take the recipients set automatically by docusign
Most of my code wasfollowing the quickstart guide
Yes I have read, but found the answers unhelpful.
Docusign embedded signing request from template and Docusign Embedded Signing using template
function makeEnvelope(args){
// create the envelope definition
let env = new docusign.EnvelopeDefinition();
env.templateId = args.templateId;
// Create template role elements to connect the signer and cc recipients
// to the template
// We're setting the parameters via the object creation
let signer1 = docusign.TemplateRole.constructFromObject({
email: args.signerEmail,
name: args.signerName,
clientUserId: '1',
roleName: 'signer'});
// Add the TemplateRole objects to the envelope object
env.templateRoles = [signer1];
env.status = "sent"; // We want the envelope to be sent
return env;
}
{
let dsApiClient = new docusign.ApiClient();
dsApiClient.setBasePath(args.basePath);
dsApiClient.addDefaultHeader('Authorization', 'Bearer ' + args.accessToken);
let envelopesApi = new docusign.EnvelopesApi(dsApiClient);
// Step 1. Make the envelope request body (function above)
let envelope = makeEnvelope(args.envelopeArgs)
// Step 2. call Envelopes::create API method
// Exceptions will be caught by the calling function
let results = await envelopesApi.createEnvelope(
args.accountId, {envelopeDefinition: envelope});
return results;
}
function makeRecipientViewRequest(args) {
let viewRequest = new docusign.RecipientViewRequest();
viewRequest.returnUrl = args.dsReturnUrl + "?state=123";
viewRequest.authenticationMethod = 'none';
viewRequest.email = args.signerEmail;
viewRequest.userName = args.signerName;
viewRequest.clientUserId = args.signerClientId;
viewRequest.pingFrequency = 600; // seconds
viewRequest.pingUrl = args.dsPingUrl; // optional setting
return viewRequest
}

DocuSign - View Form Data

Another company we partner with sends us new client information via DocuSign envelopes completed by those clients. I am attempting to extract the form data from the document, either via the PDF or via the DocuSign API. The PDF only appears to have the Envelope ID embedded in it. When I add my account as a CC recipient and try to view the form data in the DocuSign console, I receive an error message:
Additionally, I'm unable to view the form data via the DocuSign API.
{
errorCode: "USER_LACKS_PERMISSIONS",
message: "This user lacks sufficient permissions to access this resource."
}
I've tried accessing via the API at:
/v2/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs
/v2/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields
Questions:
Is there a way for a user who is not in the sender's tenant to be able to view the envelope form data?
Is there a way for DocuSign to embed the tab data into the PDF for extraction?
Is there another approach I'm not considering?
If the user is cc to the envelope using the same userId and email combination that is on their account, then that user also can use the API to gain account information. (account is what you call "tenant.")
If the user is not on the envelope and you just receive the PDF some other way, then you cannot use the API to obtain information about the envelope because that is limited only to recipients of the envelope.
#Inbar-Gazit was kind enough to do some digging internally at DocuSign, and after a bit of back-and-forth, discovered that this is possible using the SOAP API with the RequestEnvelope and RequestEnvelopeV2 methods. I'm unsure if there's any advantage to using one method over the other. Both also have async methods.
https://developers.docusign.com/docs/esign-soap-api/reference/Status-and-Managing-Group/RequestEnvelope
Some quick-and-dirty C# validated that this will indeed work. I validated this both as the sending account (which also works via REST) and the CC recipient account (which did not work via REST).
var authString = $"<DocuSignCredentials><Username>{_userName}</Username><Password>{_password}</Password><IntegratorKey>{_apiKey}</IntegratorKey></DocuSignCredentials>";
var client = new DSAPIServiceSoapClient();
using (OperationContextScope scope = new OperationContextScope(client.InnerChannel))
{
HttpRequestMessageProperty httpRequestProperty = new HttpRequestMessageProperty();
httpRequestProperty.Headers.Add("X-DocuSign-Authentication", authString);
OperationContext.Current.OutgoingMessageProperties[HttpRequestMessageProperty.Name] = httpRequestProperty;
EnvelopeStatus status = client.RequestStatusEx(_envelopeId);
Console.Out.WriteLine("Subject: " + status.Subject);
// RequestEnvelope Method
var envelope = client.RequestEnvelope(_envelopeId, false);
var testTab = envelope.Tabs.FirstOrDefault(t => t.TabLabel.Contains("Test"));
if (testTab != null)
{
Console.WriteLine($"Tab {testTab.TabLabel}: {testTab.Value}");
} else
{
Console.WriteLine("Tab not found.");
}
// RequestEnvelopeV2 Method
var requestOptions = new RequestEnvelopeV2Options() {
IncludeAC = false,
IncludeAnchorTabLocations = true,
IncludeDocumentBytes = false
};
var envelopeV2 = client.RequestEnvelopeV2(_envelopeId, requestOptions);
var testTabV2 = envelopeV2.Tabs.FirstOrDefault(t => t.TabLabel.Contains("Test"));
if (testTabV2 != null)
{
Console.WriteLine($"Tab(v2) {testTabV2.TabLabel}: {testTabV2.Value}");
} else
{
Console.WriteLine("Tab(v2) not found.");
}
Console.WriteLine("\r\nDone.");
Console.ReadKey();
}
Output:
Subject: Please DocuSign: Test Envelope
Tab txtDataLabelTest1: Some Data Here
Tab(v2) txtDataLabelTest1: Some Data Here
Done.

How can I receive returnurl events from embedded app?

I sent envelope at embed app without client_id. Then, I can check the envelope by email, and if I signed the envelope in the email, is there a way to get an event on the embed app?
public Map<String,Object> createRecipientView(Map<String,Object> recipientInfo) {
Map<String,Object> result = new HashMap<String,Object>();
// instantiate a new EnvelopesApi object
EnvelopesApi envelopesApi = new EnvelopesApi();
// set the url where you want the recipient to go once they are done signing
RecipientViewRequest view = new RecipientViewRequest();
//view.setReturnUrl("https://www.docusign.com");
view.setReturnUrl(serverUrl+"/"+recipientInfo.get("usr_cls")+"/docusign/returnRecipientView.do?ds_usr_id="+recipientInfo.get("ds_usr_id") + "&docusign_id=" + recipientInfo.get("docusign_id")+ "&usr_cls=" + recipientInfo.get("usr_cls") + "&uiId=" +recipientInfo.get("uiId"));
view.setAuthenticationMethod("email");
// recipient information must match embedded recipient info we provided in step #2
String email = (String)recipientInfo.get("email");
String userName = (String)recipientInfo.get("usr_nm");
String recipientId = (String)recipientInfo.get("recipient_id");
String clientId = (String)recipientInfo.get("client_id");
String envelopeId = (String)recipientInfo.get("envelope_id");
view.setEmail(email);
view.setUserName(userName);
view.setRecipientId(recipientId);
//view.seta
//view.setClientUserId(clientId);
// call the CreateRecipientView API
ViewUrl recipientView;
try {
recipientView = envelopesApi.createRecipientView(accountId, envelopeId, view);
log.info("Signing URL = " + recipientView.getUrl());
result.put("url", recipientView.getUrl());
result.put("result_status", "S");
} catch (ApiException e) {
log.error("error : " + e.toString());
result.put("result_status", "F");
result.put("result_message", e.toString());
}
return result;
}
Yes, you can use webhook to get notifications about the envelope to your app.
You can read this blog post about it.
You can also look at this code example.
Here is some C# code taken from here:
EnvelopeDefinition envelopeDefinition = new EnvelopeDefinition();
var eventNotification = new EventNotification();
\\ Set up the endpoint URL to call (it must be using HTTPS and at least TLS1.1 or higher)
eventNotification.Url = "https:\\myapp.somedomain.com";
\\ DocuSign will retry on failure if this is set
eventNotification.RequireAcknowledgment = "true";
\\ This would send the documents together with the event to the endpoint
eventNotification.IncludeDocuments = "true";
\\ Allows you to see this in the DocuSign Admin Connect logs section
eventNotification.LoggingEnabled = "true";
var envelopeEvents = new List<EnvelopeEvent>();
\\ In this case we only add a single envelope event, when the envelope is completed. You can also add events for recipients
envelopeEvents.Add(new EnvelopeEvent { EnvelopeEventStatusCode = "completed", IncludeDocuments = "true" });
eventNotification.EnvelopeEvents = envelopeEvents;
envelopeDefinition.EventNotification = eventNotification;

Email notification to user is not sent when ClientUserId is provided

I'm trying to create envelope from template i uploaded to my account.
Using following code to do that:
public static void main(String[] args) throws ApiException {
// Enter your DocuSign credentials
String UserName = "my-user-name";
String Password = "my-password";
String IntegratorKey = "my-integrator-key";
// for production environment update to "www.docusign.net/restapi"
String BaseUrl = "https://demo.docusign.net/restapi";
// initialize the api client for the desired environment
ApiClient apiClient = new ApiClient();
apiClient.setBasePath(BaseUrl);
// create JSON formatted auth header
String creds = "{\"Username\":\"" + UserName + "\",\"Password\":\"" + Password + "\",\"IntegratorKey\":\"" + IntegratorKey + "\"}";
apiClient.addDefaultHeader("X-DocuSign-Authentication", creds);
// assign api client to the Configuration object
Configuration.setDefaultApiClient(apiClient);
//////////////////////////////// LOGIN START
// login call available off the AuthenticationApi
AuthenticationApi authApi = new AuthenticationApi();
// login has some optional parameters we can set
AuthenticationApi.LoginOptions loginOps = authApi.new LoginOptions();
loginOps.setApiPassword("true");
loginOps.setIncludeAccountIdGuid("true");
LoginInformation loginInfo = authApi.login(loginOps);
// note that a given user may be a member of multiple accounts
List<LoginAccount> loginAccounts = loginInfo.getLoginAccounts();
System.out.println("LoginInformation: " + loginAccounts);
// use the |accountId| we retrieved through the Login API to create the Envelope
String accountId = loginAccounts.get(0).getAccountId();
/////////////////////////////////////// LOGIN END
////////////////////////////////////// CREATE ENVELOPE START
// create a new envelope object that we will manage the signature request through
EnvelopeDefinition envDef = new EnvelopeDefinition();
envDef.setEmailSubject("Hey! Sign the following document");
// assign template information including ID and role(s)
envDef.setTemplateId("ebbe20e3-1c2e-4696-a0c4-41269bf54aeb");
// create a template role with a valid templateId and roleName and assign signer info
TemplateRole tRole = new TemplateRole();
tRole.setRoleName("Client");
String name = "Jake";
String email = "someEmail#goes.here";
tRole.setName(name);
tRole.setEmail(email);
tRole.setClientUserId("someClientUuid");
// create a list of template roles and add our newly created role
List<TemplateRole> templateRolesList = new ArrayList<>();
templateRolesList.add(tRole);
Tabs tabs = new Tabs();
Text clientIdField = new Text();
clientIdField.setTabLabel("CustomerId");
clientIdField.setValue("I changed text from API! It works!");
List<Text> textList = new ArrayList<>();
textList.add(clientIdField);
tabs.setTextTabs(textList);
tRole.setTabs(tabs);
// assign template role(s) to the envelope
envDef.setTemplateRoles(templateRolesList);
// send the envelope by setting |status| to "sent". To save as a draft set to "created"
envDef.setStatus("sent");
// use the |accountId| we retrieved through the Login API to create the Envelope
// instantiate a new EnvelopesApi object
EnvelopesApi envelopesApi = new EnvelopesApi();
// call the createEnvelope() API
EnvelopeSummary envelopeSummary = envelopesApi.createEnvelope(accountId, envDef);
System.out.println("EnvelopeSummary: " + envelopeSummary);
///////////////////////////////////// CREATE ENVELOPE END
String envelopeId = envelopeSummary.getEnvelopeId();
//////////////////////////////////////// CREATE RECIPIENT VIEW
// use the |accountId| we retrieved through the Login API
// instantiate a new EnvelopesApi object
// set the url where you want the recipient to go once they are done signing
RecipientViewRequest returnUrl = new RecipientViewRequest();
returnUrl.setReturnUrl("https://www.docusign.com/devcenter");
returnUrl.setAuthenticationMethod("email");
// recipient information must match embedded recipient info we provided in step #2
returnUrl.setEmail(email);
returnUrl.setUserName(name);
returnUrl.setClientUserId("someClientUuid");
// call the CreateRecipientView API then navigate to the URL to start the signing session
ViewUrl recipientView = envelopesApi.createRecipientView(accountId, envelopeId, returnUrl);
System.out.println("ViewUrl: " + recipientView);
//////////////////////////////////////// CREATE RECIPIENT VIEW
}
And i noticed strange thing - when i provide clientUserId field to my TemplateRole, while creating envelope from template - email notification to sign document is not sent to user. But when i remove this field - email is sent successfully.
The problem is that i need that clientUserId in my TemplateRole to be able to properly generate ViewUrl to use in my application.
So is it a bug or a feature, that notification is not sent with provided clientUserId in TemplateRole? Did not found any documentation about that on official site.
When clientUserId is specified the recipient is considered as an embedded recipient. By default only remote recipients receive email notifications.
If you want embedded recipients to receive email notifications then set the embeddedRecipientStartURL property.
tRole.setEmbeddedRecipientStartURL("SIGN_AT_DOCUSIGN")
See this answer for more information
Official Documentation

Resources