DocuSign: Successful envelope but status is not "sent" - docusignapi

I'm using node and I make an envelope with env.status = "sent", I then hit the envelopesApi.createEnvelope with said envelope. The response back says its successful but the status is "created" and no email is sent for signature to the specified signer. What am I missing? Here is the full response
{
"envelopeId": "205ed07d-8094-4031-a334-7159e1bd0f34",
"status": "created",
"statusDateTime": "2023-01-05T06:19:17.9670000Z",
"uri": "/envelopes/205ed07d-8094-4031-a334-7159e1bd0f34"
}
Also note, the simple template has a signer role on it, and a signature specified, in my code I tried both adding the signer with TemplateRole.constructFromObject, and env.templateRoles = [signer1] and also removing this code (as its specified online in the UI), both just result in status created, not sent.
Heres all the relevant code:
async sendEnvelopeFromTemplate(accessToken: string): Promise<any>{
// Data for this method
// args.basePath
// args.accessToken
// args.accountId
const basePath = docusign_account_base_uri + '/restapi'
let dsApiClient = new docusign.ApiClient();
dsApiClient.setBasePath(basePath);
dsApiClient.addDefaultHeader("Authorization", "Bearer " + accessToken);
let envelopesApi = new docusign.EnvelopesApi(dsApiClient);
// Step 1. Make the envelope request body
let envelope = this.makeEnvelope();
// Step 2. call Envelopes::create API method
// Exceptions will be caught by the calling function
try{
let results = await envelopesApi.createEnvelope(docusign_api_account_id, {
envelopeDefinition: envelope,
});
return results;
}
catch(e){
console.log("ERROR")
console.log(e)
}
};
async makeEnvelope() {
const args = {
signerEmail: 'REDACTED',
signerName: 'REDACTED',
templateId: 'REDACTED'
}
// 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,
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;
}

You need to set status to "sent" when you create the envelope.
Otherwise (your situation), your envelope is in status "created" which is equivalent to a draft envelope.

Do you have a complete template, i.e. does the template contain a document? An envelope cannot be sent if a) there isn's at least one document in the envelope, b) there must be at least one recipient.
There could be other side issues, such as not allowing "free-form signing" (no tabs specified for the signer) and the envelope has no tabs. But I'm going to assume your account is set up as default so that isn't an issue here. Also assuming you assigned a tab to the role in your template.

Was a simple async issue, I did not await the call to makeEnvelope, I was getting a success back, but the sent status was not being set, as soon as I awaited it the problem went away. Thanks for the other helpful info.
let envelope = this.makeEnvelope();
needed to be
let envelope = await this.makeEnvelope();

Related

.createEnvelope returning 'invalid Template Id'

I'm requesting a signature by email using an existing template.
After using JWT grant for successful authorization, I call the api function docusign.EnvelopesApi(dsApiClient).createEnvelope with a new envelope including my templateId.
The call results in the error: {"errorCode":"TEMPLATE_ID_INVALID","message":"Invalid template ID."}
My server is authorized successfully,
I only have a single docu-sign admin user (myself)
The templateId is correct (i've double and tripped checked)
I'm on a paying account
async function main(){
const args = makeEnvelope({
email: "signer email",
name: "Signer name",
templateId: "some template id",
});
// Make the envelope request body
let envelope = makeEnvelope(args)
let results = await new docusign.EnvelopesApi(dsApiClient).createEnvelope(
accountInfo.apiAccountId, {envelopeDefinition: envelope});
return results;
}
function makeEnvelope(args){
let env = new docusign.EnvelopeDefinition();
env.templateId = args.templateId;
let signer = docusign.TemplateRole.constructFromObject({
email: args.signerEmail,
name: args.signerName,
roleName: 'signer'});
env.templateRoles = [signer];
env.status = "sent";
return env;
}
main();
This error can mean:
TemplateID is just wrong.
TemplateID is from production or developer account, but you are using developer account or production (mismatch)
TemplateID is from a different account then the one you authenticating to.
I cannot tell which one it is, you will have to contact support for this. But instead of just double-checking your ID, you need to also double check the env (prod vs. dev) as well as the accounts, make sure it's from the same account.

Docusign nodejs envelopes api returns exports {}

I'm running the following code in my nodejs server
// Create the recipient view, the Signing Ceremony
let viewRequest: RecipientViewRequest = {
returnUrl: "http://localhost:3000/fund/123?state=123",
authenticationMethod: "none",
email: "my_email",
userName: "Ryan",
clientUserId: "my client user id",
pingFrequency: "600",
pingUrl: "http://localhost:3000"
};
// Call the CreateRecipientView API
// Exceptions will be caught by the calling function
const dsApiClient = new ApiClient();
dsApiClient.setBasePath("https://account-d.docusign.com");
const api = new EnvelopesApi(dsApiClient);
const results = await api.createRecipientView(
"1234",
"5678",
{ recipientViewRequest: viewRequest }
);
and it keeps giving me the output of exports {} no errors or anything. this is pretty painful to debug. has anyone else ran into a similar problem? and how did you fix it?
When you use embedded signing you must set the clientUserId.
But, the clientUserId has to be set when the envelope is created, or when the recipient is added to an a draft envelope and must match the value you later pass in a request for a recipient View.
You cannot make a request for recipient view for an envelope that was created via the web app, unless your code modified that envelope to set the clientUserId for the recipient you want.

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
}

How can I retrieved completed envelopes filtered by template Id?

I am retrieving all the completed envelopes, but they are from different template, is there a way to filter the retrieve, to get only the envelopes that match with a template id?
here is how a retrieve the envelopes:
dsApi = new docusign.ApiClient();
console.log("ACCESS TOKEN => " + token);
// Set headers
dsApi.setBasePath(data[0].config.docusign_base_uri);
dsApi.addDefaultHeader('Authorization', 'Bearer ' + token);
let envelopesApi = new docusign.EnvelopesApi(dsApi)
, results = null, resultsTemplate = null,
options = {fromDate: fromDate_in, toDate: toDate_in, status: status_in};
try{
results = await envelopesApi.listStatusChanges(data[0].config.docusign_account_id, options);
}catch(error){
response = { code: "400", message: error };
console.log("RES: " + JSON.stringify(response));
res.send(response);
}
I don't believe this can be done using the API without some extra work on your part.
The reason is that the envelope, once created, as no affiliation with the original template from which it was created. The template is used to get all the information into the envelope, but at that point it's like any other envelope.
You could set up some custom fields that are different for each template. You could set up different folders for the different templates. You can search on many other things that are part of the end envelope (not the template) and while it does require additional setup work, it will enable your scenario.

Prefill docusign template fields

Using the Docusign node.js sample I'm able to send a template, however I'm having trouble pre-setting the field values.
I've looked around on stack overflow and found 3 different versions of the setTemplateRoles JSON format. I've tried them all and none worked.
When I run this code, the email comes to foo#email.com and my template comes through fine, but the fields are not pre-filled.
Q1. When they say tab what are they talking about? What is a tab?
Q2. Does tabLabel mean Data Label, or are they different things?
Screenshot:
when editing the template in the GUI.
Q3. How can I add a "custom field" to my docusign template? I've tried to do it by clicking Custom Fields, and adding one. But it seems to be more of a field template than a specific custom field.
When I run the API call listCustomFields, it comes back empty.
var docusign = require('docusign-esign');
// Note: Following values are class members for readability and easy testing
// TODO: Enter your DocuSign credentials
var UserName = 'foo#email.com';
var Password = 'SECRET1';
// TODO: Enter your Integrator Key (aka API key), created through your developer sandbox preferences
var IntegratorKey = 'SECRET2';
// for production environment update to 'www.docusign.net/restapi'
var BaseUrl = 'https://demo.docusign.net/restapi';
var RequestSignatureFromTemplate = function () {
// TODO: Enter signer information and template info from a template in your account
var signerName = 'Bob';
var signerEmail = 'foo#email.com';
var subject = "testing 123";
var templateId = 'XXX';
var templateRoleName = 'Seller';
// initialize the api client
var apiClient = new docusign.ApiClient();
apiClient.setBasePath(BaseUrl);
// create JSON formatted auth header
var creds = '{"Username":"' + UserName + '","Password":"' + Password + '","IntegratorKey":"' + IntegratorKey + '"}';
apiClient.addDefaultHeader('X-DocuSign-Authentication', creds);
// assign api client to the Configuration object
docusign.Configuration.default.setDefaultApiClient(apiClient);
// ===============================================================================
// Step 1: Login() API
// ===============================================================================
// login call available off the AuthenticationApi
var authApi = new docusign.AuthenticationApi();
// login has some optional parameters we can set
var loginOps = new authApi.LoginOptions();
loginOps.setApiPassword('true');
loginOps.setIncludeAccountIdGuid('true');
authApi.login(loginOps, function (error, loginInfo, response) {
if (error) {
console.log('Error: ' + error);
return;
}
if (loginInfo) {
// list of user account(s)
// note that a given user may be a member of multiple accounts
var loginAccounts = loginInfo.getLoginAccounts();
console.log('LoginInformation: ' + JSON.stringify(loginAccounts));
// ===============================================================================
// Step 2: Create Envelope API (AKA Signature Request) from a Template
// ===============================================================================
// create a new envelope object that we will manage the signature request through
var envDef = new docusign.EnvelopeDefinition();
envDef.setEmailSubject(subject);
envDef.setTemplateId(templateId);
envDef.setTemplateRoles([
{email:'foo#email.com',
name:'bob',
roleName:'Seller',
// tabStatuses:[
// {tabStatus:[{
// tabLabel:'sellerName',
// tabValue:'test123'
// }]}
// ]
tabs:
{textTabs:[{
tabLabel:'sellerName',
tabName:'sellerName',
tabValue:'test123'
}]},
// tabStatuses:
// {textTabs:[{
// tabLabel:'sellerName',
// tabName:'sellerName',
// tabValue:'test123'
// }]}
}
]);
// console.log("eid", envDef.getEnvelopeId()); //undefined
//I commented out the following example code. I looked through the docusign-esign source and it didn't seem to have a way to add tabStatuses (whatever that means) so I used the above code instead. Which works as far as sending the email, but doesn't work for pre-filling the fields.
// create a template role with a valid templateId and roleName and assign signer info
// var tRole = new docusign.TemplateRole();
// tRole.setRoleName(templateRoleName);
// tRole.setName(signerName);
// tRole.setEmail(signerEmail);
//
// // create a list of template roles and add our newly created role
// var templateRolesList = [];
// templateRolesList.push(tRole);
//
// // 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
var loginAccount = new docusign.LoginAccount();
loginAccount = loginAccounts[0];
var accountId = loginAccount.accountId;
//it gets a little messy with junk experimental code. But what's not commented out is the same as the example, except I've added an additional callback in the deepest function.
// instantiate a new EnvelopesApi object
var envelopesApi = new docusign.EnvelopesApi();
// envelopesApi.getDocuments(loginAccount.accountId)
// call the createEnvelope() API
envelopesApi.createEnvelope(accountId, envDef, null, function (error, envelopeSummary, response) {
if (error) {
console.log('Error: ' + error);
return;
}
if (envelopeSummary) {
console.log('EnvelopeSummary: ' + JSON.stringify(envelopeSummary));
var envelopeId = envelopeSummary.envelopeId;
console.log("envelopeId", envelopeId);
// envelopesApi.listDocuments(accountId, envelopeId, function (error, data, response) {
// if (error) {console.log("error", error);return;}
// console.log("data", data);
// console.log("response", response);
// });
//envelopesApi.getDocument downloads the PDF binary 2.5MiB.
var documentId = '1';
var chunks=[];
envelopesApi.listCustomFields(accountId, envelopeId, function (error, data, response) {
if (error) {console.log("error", error);return;}
console.log("typeof data", typeof data);
// console.log("data.length", data.length);
// // console.log("response", response);
// response.on('data',chunk => chunks.push(chunk));
// response.on('end',()=>{
// var allChunks = chunks.join('');
// console.log("allChunks", allChunks);
// });
console.log("data", data);
// console.log("data.toJson()", data.toJson());
console.log("data.getTextCustomFields()", data.getTextCustomFields());
});
}
});
}
});
}; // end RequestSignatureFromTemplate()
When they say tab what are they talking about? What is a tab?
Tabs - aka fields or tags- can be added to documents and templates and are used several ways.
First they are used to indicate to a recipient where a signature or initials are required.
Second, they can be used to show data or information to recipients, such as dates, names, addresses, and other data.
Third, tabs can be used as editable information fields so you can retrieve data or information from your recipients
More information here
Does tabLabel mean Data Label, or are they different things?
Yes they are the same.
If you give tabs of the same type the same tabLabel when a recipient updates one tab it will update all the others with the same data in real-time.
More information here (see "Shared Tab Labels" section)
How can I add a "custom field" to my docusign template? I've tried to do it by clicking Custom Fields, and adding one. But it seems to be more of a field template than a specific custom field. When I run the API call listCustomFields, it comes back empty.
A "custom field" could mean several things.
See this answer for more information.
If you are looking for the Tabs on a document then you should explore the listEnvelopeTabs api
My template comes through fine, but the fields are not pre-filled.
If you are looking for pre-filled Fields (aka Tabs), you should set the "value" property in your request. More info here
Here is the raw Json request.
"tabs": {
"textTabs": [
{
"value": "$100",
"xPosition": "300",
"yPosition": "200",
"documentId": "1",
"pageNumber": "1"
}]
}

Resources