public async Task<SignatureRequest> SendWithTemplateAsync(SignatureRequestFromTemplateRequest request)
{
SignatureRequestWrapper signatureRequestWrapper = await helloSignService.MakeRequestAsync<SignatureRequestWrapper>(
settings.HelloSignSettings.Endpoints.SignatureRequest.SendWithTemplate,
request);
return signatureRequestWrapper.SignatureRequest;
}
public async Task SendWithFullTemplateTest()
{
if (string.IsNullOrEmpty(Config.FullOrderedTemplateId))
{
Assert.Inconclusive("Config.FullTemplateId needs to be set before running this test");
return;
}
var fullTemplate = await client.Template.GetAsync(Config.FullOrderedTemplateId);
Assert.IsNotNull(fullTemplate);
Assert.IsTrue(fullTemplate.SignerRoles.Count > 1, "FullTemplate should have multiple signatures");
var signers = new Dictionary<string, SignatureRequestSignerRoleRequest>();
for (var i = 0; i < fullTemplate.SignerRoles.Count; i++)
{
var role = fullTemplate.SignerRoles[i];
signers.Add(role.Name, new SignatureRequestSignerRoleRequest() { Name = string.Format("TestName{0}", i), EmailAddress = string.Format("test{0}@test.com", i) });
}
var customFields = new Dictionary<string, object>();
var iField = 0;
var sourceFields = fullTemplate.Documents.SelectMany(d => d.CustomFields);
if (!sourceFields.Any(f => f.Type == FieldTypes.Checkbox) || !sourceFields.Any(f => f.Type == FieldTypes.Text))
{
Assert.Inconclusive("FullTemplate should have at least one text and one checkbox field for conclusive test");
}
foreach (var field in fullTemplate.Documents.SelectMany(d => d.CustomFields))
{
iField++;
if (field.Type == FieldTypes.Checkbox)
customFields.Add(field.Name, true);
else
customFields.Add(field.Name, string.Format("TestFieldValue{0}", iField));
}
var ccs = new Dictionary<string, string>();
var iCC = 0;
foreach (var roles in fullTemplate.CcRoles)
{
ccs.Add(roles.Name, string.Format("testcc{0}@test.com", iCC++));
}
if (ccs.Count < 2)
{
Assert.Inconclusive("FullTemplate should have at least two cc fields for conclusive test");
}
var sendRequest = new SignatureRequestFromTemplateRequest
{
TestMode = 1,
TemplateIds = new List<string> { Config.FullOrderedTemplateId },
Title = "Test Custom Title",
Subject = "Test Custom Subject",
Message = "Test Custom Message",
Signers = signers,
CustomFields = customFields,
Ccs = ccs,
//ClientId = "",
Metadata = new Dictionary<string, string>
{
{ "isHelloSignApiTest", "true" },
{ "testkey1", "testdata1" },
{ "testkey2", "testdata2" }
},
SigningRedirectUrl = "http://test.com/redirect"
};
var signatureRequest = await client.SignatureRequest.SendWithTemplateAsync(sendRequest);
Assert.IsNotNull(signatureRequest);
Assert.IsNotNull(signatureRequest.SignatureRequestId);
try
{
Assert.AreNotEqual(string.Empty, signatureRequest.SignatureRequestId);
Assert.AreEqual("Test Custom Title", signatureRequest.Title);
Assert.AreEqual("Test Custom Subject", signatureRequest.Subject);
Assert.AreEqual("Test Custom Message", signatureRequest.Message);
Assert.AreEqual(Config.Username, signatureRequest.RequesterEmailAddress);
Assert.AreEqual("http://test.com/redirect", signatureRequest.SigningRedirectUrl);
Assert.AreEqual(true, signatureRequest.TestMode);
Assert.IsNotNull(signatureRequest.DetailsUrl);
Assert.AreNotEqual(string.Empty, signatureRequest.DetailsUrl);
Assert.IsNotNull(signatureRequest.FilesUrl);
Assert.AreNotEqual(string.Empty, signatureRequest.FilesUrl);
Assert.AreEqual(false, signatureRequest.HasError);
Assert.AreEqual(false, signatureRequest.IsComplete);
Assert.IsNotNull(signatureRequest.SigningUrl);
Assert.AreNotEqual(string.Empty, signatureRequest.SigningUrl);
Assert.IsNotNull(signatureRequest.ResponseData);
Assert.AreEqual(0, signatureRequest.ResponseData.Count);
Assert.IsNotNull(signatureRequest.Metadata);
Assert.AreEqual(3, signatureRequest.Metadata.Count);
Assert.AreEqual("true", signatureRequest.Metadata?["isHelloSignApiTest"]);
Assert.AreEqual("testdata1", signatureRequest.Metadata?["testkey1"]);
Assert.AreEqual("testdata2", signatureRequest.Metadata?["testkey2"]);
Assert.AreEqual(signers.Count, signatureRequest.Signatures.Count);
// Not Ideal, but since we can't really control the template, check based on template
// versus literal values
foreach (var signature in signatureRequest.Signatures)
{
var signerEntry = signers.FirstOrDefault(s => s.Value.EmailAddress == signature.SignerEmailAddress);
Assert.IsNotNull(signerEntry);
Assert.AreEqual(!string.IsNullOrEmpty(signerEntry.Value.Pin), signature.HasPin);
Assert.IsNull(signature.LastRemindedAt);
Assert.IsNull(signature.LastViewedAt);
var role = fullTemplate.SignerRoles.FirstOrDefault(r => r.Name == signerEntry.Key);
Assert.AreEqual(role.Order, signature.Order);
Assert.IsNotNull(signature.SignatureId);
Assert.IsNull(signature.SignedAt);
Assert.AreEqual(signerEntry.Value.EmailAddress, signature.SignerEmailAddress);
Assert.AreEqual(signerEntry.Value.Name, signature.SignerName);
Assert.AreEqual(SignatureStatusCodes.AwaitingSignature, signature.StatusCode);
}
Assert.IsNotNull(signatureRequest.CustomFields);
Assert.AreEqual(sourceFields.Count(), signatureRequest.CustomFields.Count);
foreach (var field in signatureRequest.CustomFields)
{
var source = sourceFields.FirstOrDefault(sf => sf.Name == field.Name);
var sentField = customFields.FirstOrDefault(cf => cf.Key == field.Name);
Assert.IsNotNull(source);
Assert.IsNotNull(sentField);
Assert.AreEqual(source.Name, field.Name);
Assert.AreEqual(source.Type, field.Type);
Assert.AreEqual(sentField.Value, field.Value);
}
Assert.IsNotNull(signatureRequest.CcEmailAddresses);
Assert.AreEqual(ccs.Count(), signatureRequest.CcEmailAddresses.Count);
foreach (var cc in signatureRequest.CcEmailAddresses)
{
var sourceCC = ccs.FirstOrDefault(c => c.Value == cc);
Assert.IsNotNull(sourceCC);
Assert.AreEqual(sourceCC.Value, cc);
}
}
finally
{
var result = await client.SignatureRequest.CancelAsync(signatureRequest.SignatureRequestId);
Assert.IsTrue(result);
}
}
public async Task SendWithSimpleTemplateTest()
{
if (string.IsNullOrEmpty(Config.SimpleUnorderedTemplateId))
{
Assert.Inconclusive("Config.SimpleTemplateId needs to be set before running this test");
return;
}
var template = await client.Template.GetAsync(Config.SimpleUnorderedTemplateId);
Assert.IsNotNull(template);
if (template.SignerRoles.Count != 1)
{
Assert.Inconclusive("Template specified by Config.SimpleTemplateId must have only one SignerRole defined");
return;
}
var sendRequest = new SignatureRequestFromTemplateRequest
{
TestMode = 1,
TemplateIds = new List<string> { Config.SimpleUnorderedTemplateId },
Signers = new Dictionary<string, SignatureRequestSignerRoleRequest>()
{
{ template.SignerRoles[0].Name, new SignatureRequestSignerRoleRequest { Name = "TestName1", EmailAddress = "*****@*****.**" } },
}
};
var signatureRequest = await client.SignatureRequest.SendWithTemplateAsync(sendRequest);
Assert.IsNotNull(signatureRequest);
Assert.IsNotNull(signatureRequest.SignatureRequestId);
try
{
Assert.AreEqual(template.Title, signatureRequest.Title);
Assert.AreEqual(template.Message, signatureRequest.Message);
Assert.AreEqual(1, signatureRequest.Signatures.Count);
Assert.IsNull(signatureRequest.Signatures[0].Order);
Assert.AreEqual("*****@*****.**", signatureRequest.Signatures[0].SignerEmailAddress);
Assert.AreEqual("TestName1", signatureRequest.Signatures[0].SignerName);
Assert.AreEqual(false, signatureRequest.Signatures[0].HasPin);
Assert.AreEqual(SignatureStatusCodes.AwaitingSignature, signatureRequest.Signatures[0].StatusCode);
Assert.IsNotNull(signatureRequest.CustomFields);
Assert.AreEqual(template.Documents.Sum(d => d.CustomFields.Count), signatureRequest.CustomFields.Count);
Assert.IsNotNull(signatureRequest.CcEmailAddresses);
Assert.AreEqual(template.CcRoles.Count, signatureRequest.CcEmailAddresses.Count);
}
finally
{
var result = await client.SignatureRequest.CancelAsync(signatureRequest.SignatureRequestId);
Assert.IsTrue(result);
}
}
