public void VerifyResult()
{
CreatePackageFromTemplateExample example = new CreatePackageFromTemplateExample();
example.Run();
DocumentPackage documentPackage = example.RetrievedPackage;
Document document = documentPackage.GetDocument(example.DOCUMENT_NAME);
Assert.AreEqual(document.Name, example.DOCUMENT_NAME);
Assert.AreEqual(document.Id, example.DOCUMENT_ID);
Assert.AreEqual(documentPackage.Name, example.PackageName);
Assert.AreEqual(documentPackage.Description, example.PACKAGE_DESCRIPTION);
Assert.AreEqual(documentPackage.EmailMessage, example.PACKAGE_EMAIL_MESSAGE2);
Assert.AreEqual(documentPackage.Signers.Count, 3);
Assert.AreEqual(documentPackage.GetSigner(example.email1).FirstName, example.PACKAGE_SIGNER1_FIRST);
Assert.AreEqual(documentPackage.GetSigner(example.email1).LastName, example.PACKAGE_SIGNER1_LAST);
Assert.AreEqual(documentPackage.GetSigner(example.email2).FirstName, example.PACKAGE_SIGNER2_FIRST);
Assert.AreEqual(documentPackage.GetSigner(example.email2).LastName, example.PACKAGE_SIGNER2_LAST);
// TODO: Make sure that this is correctly preserved.
Assert.IsFalse(documentPackage.Settings.EnableInPerson.Value);
Assert.IsFalse(documentPackage.Settings.EnableDecline.Value);
Assert.IsFalse(documentPackage.Settings.EnableOptOut.Value);
Assert.IsFalse(documentPackage.Settings.HideWatermark.Value);
}
public void VerifyResult()
{
SignerSSOExample example = new SignerSSOExample();
example.Run();
DocumentPackage documentPackage = example.RetrievedPackage;
Assert.AreEqual(documentPackage.GetSigner(example.email4).AuthenticationMethod, AuthenticationMethod.SSO);
Assert.AreEqual(documentPackage.GetSigner(example.email4).ChallengeQuestion.Count, 0);
}
public void VerifyResult()
{
SignerSMSAuthenticationExample example = new SignerSMSAuthenticationExample();
example.Run();
DocumentPackage documentPackage = example.RetrievedPackage;
Assert.AreEqual(documentPackage.GetSigner(example.email1).AuthenticationMethod, AuthenticationMethod.SMS);
Assert.AreEqual(documentPackage.GetSigner(example.email1).ChallengeQuestion.Count, 0);
Assert.AreEqual(documentPackage.GetSigner(example.email1).Authentication.PhoneNumber, example.sms1);
Assert.AreEqual(documentPackage.GetSigner(example.email1).PhoneNumber, example.sms1);
}
public void VerifyResult()
{
TemplateExample example = new TemplateExample( );
example.Run();
DocumentPackage template = example.OssClient.GetPackage(example.templateId);
Assert.AreEqual(example.UPDATED_TEMPLATE_NAME, template.Name);
Assert.AreEqual(example.UPDATED_TEMPLATE_DESCRIPTION, template.Description);
DocumentPackage documentPackage = example.OssClient.GetPackage(example.instantiatedTemplateId);
Assert.AreEqual(example.PACKAGE_NAME, documentPackage.Name);
Assert.AreEqual(example.SIGNER1_FIRST_NAME, documentPackage.GetSigner(example.email1).FirstName);
Assert.AreEqual(example.SIGNER1_LAST_NAME, documentPackage.GetSigner(example.email1).LastName);
Assert.AreEqual(example.SIGNER1_TITLE, documentPackage.GetSigner(example.email1).Title);
Assert.AreEqual(example.SIGNER1_COMPANY, documentPackage.GetSigner(example.email1).Company);
Assert.AreEqual(example.SIGNER2_FIRST_NAME, documentPackage.GetSigner(example.email2).FirstName);
Assert.AreEqual(example.SIGNER2_LAST_NAME, documentPackage.GetSigner(example.email2).LastName);
Assert.AreEqual(example.SIGNER2_TITLE, documentPackage.GetSigner(example.email2).Title);
Assert.AreEqual(example.SIGNER2_COMPANY, documentPackage.GetSigner(example.email2).Company);
}
public void VerifyResult()
{
MixedSignerAuthenticationExample example = new MixedSignerAuthenticationExample();
example.Run();
DocumentPackage documentPackage = example.RetrievedPackage;
Signer canadianSigner = documentPackage.GetSigner(example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.Email);
SignerInformationForEquifaxCanada canadianSignerInformationForEquifaxCanada = canadianSigner.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada;
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.FirstName, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.FirstName);
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.LastName, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.LastName);
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.StreetAddress, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.StreetAddress);
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.City, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.City);
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.Province, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.Province);
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.PostalCode, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.PostalCode);
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.TimeAtAddress, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.TimeAtAddress);
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.DriversLicenseNumber, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.DriversLicenseNumber);
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.SocialInsuranceNumber, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.SocialInsuranceNumber);
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.HomePhoneNumber, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.HomePhoneNumber);
Assert.AreEqual(canadianSignerInformationForEquifaxCanada.DateOfBirth, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada.DateOfBirth);
// Note that for security reasons, the backend doesn't return challenge answers, so we don't verify the answers here.
foreach (Challenge challenge in canadianSigner.ChallengeQuestion)
{
Assert.IsTrue(String.Equals(challenge.Question, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.ChallengeQuestion[0].Question) || String.Equals(challenge.Question, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_CANADA.ChallengeQuestion[1].Question));
}
Signer usaSigner = documentPackage.GetSigner(example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.Email);
SignerInformationForEquifaxUSA usaSignerInformationForEquifaxUSA = usaSigner.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA;
Assert.AreEqual(usaSignerInformationForEquifaxUSA.FirstName, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.FirstName);
Assert.AreEqual(usaSignerInformationForEquifaxUSA.LastName, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.LastName);
Assert.AreEqual(usaSignerInformationForEquifaxUSA.StreetAddress, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.StreetAddress);
Assert.AreEqual(usaSignerInformationForEquifaxUSA.City, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.City);
Assert.AreEqual(usaSignerInformationForEquifaxUSA.State, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.State);
Assert.AreEqual(usaSignerInformationForEquifaxUSA.Zip, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.Zip);
Assert.AreEqual(usaSignerInformationForEquifaxUSA.SocialSecurityNumber, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.SocialSecurityNumber);
Assert.AreEqual(usaSignerInformationForEquifaxUSA.HomePhoneNumber, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.HomePhoneNumber);
Assert.AreEqual(usaSignerInformationForEquifaxUSA.DateOfBirth, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.DateOfBirth);
Assert.AreEqual(usaSignerInformationForEquifaxUSA.TimeAtAddress, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.TimeAtAddress);
Assert.AreEqual(usaSignerInformationForEquifaxUSA.DriversLicenseNumber, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA.DriversLicenseNumber);
foreach (Challenge challenge in usaSigner.ChallengeQuestion)
{
Assert.IsTrue(String.Equals(challenge.Question, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.ChallengeQuestion[0].Question) || String.Equals(challenge.Question, example.SIGNER_WITH_AUTHENTICATION_EQUIFAX_USA.ChallengeQuestion[1].Question));
}
}
public void VerifyResult()
{
SignerOrderingExample example = new SignerOrderingExample( );
example.Run();
// Initial signing order
DocumentPackage beforeReorder = example.savedPackage;
Assert.AreEqual(beforeReorder.GetSigner(example.email1).SigningOrder, 1);
Assert.AreEqual(beforeReorder.GetSigner(example.email2).SigningOrder, 2);
// After reordering signers
DocumentPackage afterReorder = example.afterReorder;
Assert.AreEqual(afterReorder.GetSigner(example.email1).SigningOrder, 2);
Assert.AreEqual(afterReorder.GetSigner(example.email2).SigningOrder, 1);
}
public void VerifyResult()
{
SignerSpecificEmailMessageExample example = new SignerSpecificEmailMessageExample();
example.Run();
DocumentPackage documentPackage = example.RetrievedPackage;
Assert.AreEqual(documentPackage.GetSigner(example.email1).Message, example.EMAIL_MESSAGE);
}
public void VerifyResult()
{
CreateTemplateFromPackageExample example = new CreateTemplateFromPackageExample();
example.Run();
DocumentPackage templatePackage = example.EslClient.GetPackage(example.TemplateId);
Document document = templatePackage.GetDocument(example.DOCUMENT_NAME);
Assert.AreEqual(document.Name, example.DOCUMENT_NAME);
Assert.AreEqual(document.Id, example.DOCUMENT_ID);
Assert.AreEqual(templatePackage.Name, example.PACKAGE_NAME_NEW);
// TODO: Make sure that this is correctly preserved.
Assert.AreEqual(templatePackage.Signers.Count, 3);
Assert.AreEqual(templatePackage.GetSigner(example.email1).FirstName, example.PACKAGE_SIGNER1_FIRST);
Assert.AreEqual(templatePackage.GetSigner(example.email1).LastName, example.PACKAGE_SIGNER1_LAST);
Assert.AreEqual(templatePackage.GetSigner(example.email2).FirstName, example.PACKAGE_SIGNER2_FIRST);
Assert.AreEqual(templatePackage.GetSigner(example.email2).LastName, example.PACKAGE_SIGNER2_LAST);
}
public void VerifyResult()
{
AuthenticationMethodsExample example = new AuthenticationMethodsExample();
example.Run();
DocumentPackage documentPackage = example.RetrievedPackage;
Assert.AreEqual(documentPackage.GetSigner(example.email1).AuthenticationMethod, AuthenticationMethod.EMAIL);
Assert.AreEqual(documentPackage.GetSigner(example.email1).ChallengeQuestion.Count, 0);
Assert.IsNull(documentPackage.GetSigner(example.email2).PhoneNumber);
Assert.AreEqual(documentPackage.GetSigner(example.email2).AuthenticationMethod, AuthenticationMethod.CHALLENGE);
Assert.AreEqual(documentPackage.GetSigner(example.email2).ChallengeQuestion[0].Question, AuthenticationMethodsExample.QUESTION1);
Assert.AreEqual(documentPackage.GetSigner(example.email2).ChallengeQuestion[1].Question, AuthenticationMethodsExample.QUESTION2);
Assert.IsNull(documentPackage.GetSigner(example.email2).PhoneNumber);
Assert.AreEqual(documentPackage.GetSigner(example.email3).AuthenticationMethod, AuthenticationMethod.SMS);
Assert.AreEqual(documentPackage.GetSigner(example.email3).ChallengeQuestion.Count, 0);
Assert.AreEqual(documentPackage.GetSigner(example.email3).PhoneNumber, example.sms3);
}
public void VerifyResult()
{
SignerQnAChallengeExample example = new SignerQnAChallengeExample();
example.Run();
DocumentPackage documentPackage = example.RetrievedPackage;
// Note that for security reasons, the backend doesn't return challenge answers, so we don't verify the answers here.
foreach (Challenge challenge in documentPackage.GetSigner(example.email1).ChallengeQuestion)
{
Assert.IsTrue(String.Equals(challenge.Question, example.FIRST_QUESTION) || String.Equals(challenge.Question, example.SECOND_QUESTION));
}
}
private void verifySenderInfo(DocumentPackage documentPackage)
{
SenderInfo senderInfo = documentPackage.SenderInfo;
Assert.AreEqual(example.SENDER_FIRST_NAME, senderInfo.FirstName);
Assert.AreEqual(example.SENDER_LAST_NAME, senderInfo.LastName);
Assert.AreEqual(example.SENDER_TITLE, senderInfo.Title);
Assert.AreEqual(example.SENDER_COMPANY, senderInfo.Company);
Signer sender = documentPackage.GetSigner(example.senderEmail);
Assert.AreEqual(example.SENDER_FIRST_NAME, sender.FirstName);
Assert.AreEqual(example.SENDER_LAST_NAME, sender.LastName);
Assert.AreEqual(example.senderEmail, sender.Email);
Assert.AreEqual(example.SENDER_TITLE, sender.Title);
Assert.AreEqual(example.SENDER_COMPANY, sender.Company);
}
public void VerifyResult()
{
SignerInformationForEquifaxCanadaExample example = new SignerInformationForEquifaxCanadaExample();
example.Run();
DocumentPackage documentPackage = example.RetrievedPackage;
SignerInformationForEquifaxCanada signerInformationForEquifaxCanada = documentPackage.GetSigner(example.email1).KnowledgeBasedAuthentication.SignerInformationForEquifaxCanada;
Assert.AreEqual(signerInformationForEquifaxCanada.FirstName, example.FIRST_NAME);
Assert.AreEqual(signerInformationForEquifaxCanada.LastName, example.LAST_NAME);
Assert.AreEqual(signerInformationForEquifaxCanada.StreetAddress, example.STREET_ADDRESS);
Assert.AreEqual(signerInformationForEquifaxCanada.City, example.CITY);
Assert.AreEqual(signerInformationForEquifaxCanada.Province, example.PROVINCE);
Assert.AreEqual(signerInformationForEquifaxCanada.PostalCode, example.POSTAL_CODE);
Assert.AreEqual(signerInformationForEquifaxCanada.TimeAtAddress, example.TIME_AT_ADDRESS);
Assert.AreEqual(signerInformationForEquifaxCanada.DriversLicenseNumber, example.DRIVERS_LICENSE_NUMBER);
Assert.AreEqual(signerInformationForEquifaxCanada.SocialInsuranceNumber, example.SOCIAL_INSURANCE_NUMBER);
Assert.AreEqual(signerInformationForEquifaxCanada.HomePhoneNumber, example.HOME_PHONE_NUMBER);
Assert.AreEqual(signerInformationForEquifaxCanada.DateOfBirth, example.DATE_OF_BIRTH);
}
public void VerifyResult()
{
SignerInformationForEquifaxUSAExample example = new SignerInformationForEquifaxUSAExample();
example.Run();
DocumentPackage documentPackage = example.RetrievedPackage;
SignerInformationForEquifaxUSA signerInformationForEquifaxUSA = documentPackage.GetSigner(example.email1).KnowledgeBasedAuthentication.SignerInformationForEquifaxUSA;
Assert.AreEqual(signerInformationForEquifaxUSA.FirstName, example.FIRST_NAME);
Assert.AreEqual(signerInformationForEquifaxUSA.LastName, example.LAST_NAME);
Assert.AreEqual(signerInformationForEquifaxUSA.StreetAddress, example.STREET_ADDRESS);
Assert.AreEqual(signerInformationForEquifaxUSA.City, example.CITY);
Assert.AreEqual(signerInformationForEquifaxUSA.State, example.STATE);
Assert.AreEqual(signerInformationForEquifaxUSA.Zip, example.ZIP);
Assert.AreEqual(signerInformationForEquifaxUSA.TimeAtAddress, example.TIME_AT_ADDRESS);
Assert.AreEqual(signerInformationForEquifaxUSA.SocialSecurityNumber, example.SOCIAL_SECURITY_NUMBER);
Assert.AreEqual(signerInformationForEquifaxUSA.HomePhoneNumber, example.HOME_PHONE_NUMBER);
Assert.AreEqual(signerInformationForEquifaxUSA.DateOfBirth, example.DATE_OF_BIRTH);
Assert.AreEqual(signerInformationForEquifaxUSA.DriversLicenseNumber, example.DRIVERS_LICENSE_NUMBER);
}
public void VerifyResult()
{
IdvAuthExample example = new IdvAuthExample();
example.Run();
DocumentPackage retrievedPackage = example.RetrievedPackage;
AssertIdvWorkflowConfigs(new List <IdvWorkflowConfig>(), example.idvWorkflowConfigsBeforeCreating);
AssertIdvWorkflowConfigs(example.idvWorkflowConfigsToBeCreated, example.idvWorkflowConfigsAfterCreating);
AssertIdvWorkflowConfigs(example.idvWorkflowConfigsToBeUpdated, example.idvWorkflowConfigsAfterUpdating);
AssertIdvWorkflowConfigs(new List <IdvWorkflowConfig>(), example.idvWorkflowConfigsAfterDeleting);
Signer signer = retrievedPackage.GetSigner(example.email1);
Assert.AreEqual(AuthenticationMethod.IDV, signer.AuthenticationMethod);
Assert.AreEqual(0, signer.ChallengeQuestion.Count);
Assert.AreEqual(IdvAuthExample.PHONE_NUMBER, signer.PhoneNumber);
IdvWorkflow idvWorkflow = signer.Authentication.IdvWorkflow;
Assert.AreEqual(IdvAuthExample.IDV_WORKFLOW_ID1, idvWorkflow.Id);
Assert.AreEqual(IdvAuthExample.TENANT, idvWorkflow.Tenant);
}
public void VerifyResult()
{
BasicPackageCreationExample example = new BasicPackageCreationExample();
example.Run();
DocumentPackage documentPackage = example.RetrievedPackage;
// Verify if the package is created correctly
Assert.AreEqual("This is a package created using the eSignLive SDK", documentPackage.Description);
Assert.AreEqual("This message should be delivered to all signers", documentPackage.EmailMessage);
Assert.AreEqual(false, documentPackage.Settings.EnableInPerson);
// Verify if the sdk version is set correctly
Assert.IsTrue(documentPackage.Attributes.Contents.ContainsKey("sdk"));
Assert.IsTrue(documentPackage.Attributes.Contents["sdk"].ToString().Contains(".NET"));
// Verify if the origin is set correctly
Assert.IsTrue(documentPackage.Attributes.Contents.ContainsKey("origin"));
Assert.IsTrue(documentPackage.Attributes.Contents["origin"].ToString().Contains("api"));
// Signer 1
Signer signer = documentPackage.GetSigner(example.email1);
Assert.AreEqual("Client1", signer.Id);
Assert.AreEqual("John", signer.FirstName);
Assert.AreEqual("Smith", signer.LastName);
Assert.AreEqual("Managing Director", signer.Title);
Assert.AreEqual("Acme Inc.", signer.Company);
// Signer 2
signer = documentPackage.GetSigner(example.email2);
Assert.AreEqual("Patty", signer.FirstName);
Assert.AreEqual("Galant", signer.LastName);
// Document 1
Document document = documentPackage.GetDocument(example.DOCUMENT1_NAME);
Assert.AreEqual(1, document.NumberOfPages);
List <Field> fields = document.Signatures[0].Fields;
Field field = fields[0];
Assert.AreEqual(FieldStyle.UNBOUND_CHECK_BOX, field.Style);
Assert.AreEqual(0, field.Page);
Assert.AreEqual(FieldBuilder.CHECKBOX_CHECKED, field.Value);
// Document 2
document = documentPackage.GetDocument(example.DOCUMENT2_NAME);
Assert.AreEqual(1, document.NumberOfPages);
fields = document.Signatures[0].Fields;
field = findFieldByName("firstField", fields);
Assert.AreEqual(FieldStyle.UNBOUND_RADIO_BUTTON, field.Style);
Assert.AreEqual(0, field.Page);
Assert.AreEqual("", field.Value);
Assert.AreEqual("group", field.Validator.Options[0]);
field = findFieldByName("secondField", fields);
Assert.AreEqual(FieldStyle.UNBOUND_RADIO_BUTTON, field.Style);
Assert.AreEqual(0, field.Page);
Assert.AreEqual(FieldBuilder.RADIO_SELECTED, field.Value);
Assert.AreEqual("group", field.Validator.Options[0]);
field = findFieldByName("thirdField", fields);
Assert.AreEqual(FieldStyle.UNBOUND_RADIO_BUTTON, field.Style);
Assert.AreEqual(0, field.Page);
Assert.AreEqual("", field.Value);
Assert.AreEqual("group", field.Validator.Options[0]);
}
override public void Execute()
{
Placeholder signer1Id = new Placeholder(Guid.NewGuid().ToString());
DocumentPackage superDuperPackage =
PackageBuilder.NewPackageNamed(PackageName)
.DescribedAs("This is a package created using the eSignLive SDK")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("firstName1")
.WithLastName("lastName1")
.WithTitle("Title1")
)
.WithSigner(SignerBuilder.NewSignerWithEmail(email2)
.WithFirstName("firstName2")
.WithLastName("lastName2")
.WithTitle("Title2")
)
.Build();
packageId = eslClient.CreatePackage(superDuperPackage);
DocumentPackage createdPackage = eslClient.GetPackage(packageId);
string signerId = createdPackage.GetSigner(email1).Id;
string signer2Id = createdPackage.GetSigner(email2).Id;
// eslClient.SignerService.UpdateSigner( packageId, signerId, SignerBuilder.NewSignerWithEmail(email1)
// .WithFirstName("firstName1b")
// .WithLastName("lastName1b")
// .WithTitle("title1b") );
string addedSignerId = eslClient.PackageService.AddSigner(packageId,
SignerBuilder.NewSignerWithEmail(email3)
.WithFirstName("firstName3")
.WithLastName("lastName3")
.WithTitle("Title3")
.Build()
);
string placeHolderId = eslClient.PackageService.AddSigner(packageId,
SignerBuilder.NewSignerPlaceholder(new Placeholder("placeHolderRoleId"))
.Build()
);
Group avengers = eslClient.GroupService.CreateGroup(GroupBuilder.NewGroup(Guid.NewGuid().ToString()).WithEmail("*****@*****.**").Build());
string addedGroupSignerId = eslClient.PackageService.AddSigner(packageId,
SignerBuilder.NewSignerFromGroup(avengers.Id)
.Build());
eslClient.PackageService.RemoveSigner(packageId, placeHolderId);
eslClient.PackageService.RemoveSigner(packageId, signerId);
eslClient.PackageService.UpdateSigner(packageId, SignerBuilder.NewSignerWithEmail("*****@*****.**")
.WithCustomId(signer2Id)
.WithFirstName("updateFirstName1")
.WithLastName("updateLastName1")
.WithTitle("UpdatedTitle1")
.Build());
Signer retrievedSigner = eslClient.PackageService.GetSigner(packageId, addedSignerId);
//eslClient.SendPackage(packageId);
eslClient.PackageService.UnlockSigner(PackageId, addedSignerId);
}
override public void Execute()
{
// Signer1 with 1 attachment requirement
signer1 = SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith")
.WithCustomId(SIGNER1_ID)
.WithAttachmentRequirement(AttachmentRequirementBuilder.NewAttachmentRequirementWithName(NAME1)
.WithDescription(DESCRIPTION1)
.IsRequiredAttachment()
.Build())
.Build();
// Signer2 with 2 attachment requirements
Signer signer2 = SignerBuilder.NewSignerWithEmail(email2)
.WithFirstName("Patty")
.WithLastName("Galant")
.WithCustomId(SIGNER2_ID)
.WithAttachmentRequirement(AttachmentRequirementBuilder.NewAttachmentRequirementWithName(NAME2)
.WithDescription(DESCRIPTION2)
.Build())
.WithAttachmentRequirement(AttachmentRequirementBuilder.NewAttachmentRequirementWithName(NAME3)
.WithDescription(DESCRIPTION3)
.IsRequiredAttachment()
.Build())
.Build();
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed(PackageName)
.DescribedAs("This is a package created using the eSignLive SDK")
.WithSigner(signer1)
.WithSigner(signer2)
.WithDocument(DocumentBuilder.NewDocumentNamed("test document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.Build())
.Build())
.Build();
packageId = eslClient.CreateAndSendPackage(superDuperPackage);
retrievedPackage = eslClient.GetPackage(packageId);
attachment1Id = retrievedPackage.GetSigner(email1).GetAttachmentRequirement(NAME1).Id;
signer1 = retrievedPackage.GetSigner(email1);
signer1Attachments = retrievedPackage.GetSigner(email1).Attachments;
signer2Attachments = retrievedPackage.GetSigner(email2).Attachments;
signer1Att1 = signer1Attachments[0];
signer2Att1 = signer2Attachments[0];
signer2Att2 = signer2Attachments[1];
retrievedSigner1Att1RequirementStatus = signer1Att1.Status;
retrievedSigner2Att1RequirementStatus = signer2Att1.Status;
retrievedSigner2Att2RequirementStatus = signer2Att2.Status;
// Upload attachment for signer1
byte[] attachment1ForSigner1FileContent = new StreamDocumentSource(attachmentInputStream1).Content();
attachment1ForSigner1FileSize = attachment1ForSigner1FileContent.Length;
eslClient.UploadAttachment(packageId, signer1Att1.Id, ATTACHMENT_FILE_NAME1, attachment1ForSigner1FileContent, SIGNER1_ID);
eslClient.UploadAttachment(packageId, signer2Att1.Id, ATTACHMENT_FILE_NAME2,
new StreamDocumentSource(attachmentInputStream2).Content(), SIGNER2_ID);
eslClient.UploadAttachment(PackageId, signer2Att2.Id, ATTACHMENT_FILE_NAME3,
new StreamDocumentSource(attachmentInputStream3).Content(), SIGNER2_ID);
// Sender rejects Signer1's uploaded attachment
eslClient.AttachmentRequirementService.RejectAttachment(packageId, signer1, NAME1, REJECTION_COMMENT);
retrievedPackageAfterRejection = eslClient.GetPackage(packageId);
retrievedSigner1Att1RequirementStatusAfterRejection = retrievedPackageAfterRejection.GetSigner(email1).GetAttachmentRequirement(NAME1).Status;
retrievedSigner1Att1RequirementSenderCommentAfterRejection = retrievedPackageAfterRejection.GetSigner(email1).GetAttachmentRequirement(NAME1).SenderComment;
// Sender accepts Signer1's uploaded attachment
eslClient.AttachmentRequirementService.AcceptAttachment(packageId, signer1, NAME1);
retrievedPackageAfterAccepting = eslClient.GetPackage(packageId);
retrievedSigner1Att1RequirementStatusAfterAccepting = retrievedPackageAfterAccepting.GetSigner(email1).GetAttachmentRequirement(NAME1).Status;
retrievedSigner1Att1RequirementSenderCommentAfterAccepting = retrievedPackageAfterAccepting.GetSigner(email1).GetAttachmentRequirement(NAME1).SenderComment;
// Download signer1's attachment
DownloadedFile downloadedAttachment = eslClient.AttachmentRequirementService.DownloadAttachmentFile(packageId, attachment1Id);
System.IO.File.WriteAllBytes(downloadedAttachment.Filename, downloadedAttachment.Contents);
// Download all attachments for the package
DownloadedFile downloadedAllAttachmentsForPackage = eslClient.AttachmentRequirementService.DownloadAllAttachmentFilesForPackage(packageId);
System.IO.File.WriteAllBytes(DOWNLOADED_ALL_ATTACHMENTS_FOR_PACKAGE_ZIP, downloadedAllAttachmentsForPackage.Contents);
// Download all attachments for the signer1 in the package
DownloadedFile downloadedAllAttachmentsForSigner1InPackage = eslClient.AttachmentRequirementService.DownloadAllAttachmentFilesForSignerInPackage(retrievedPackage, signer1);
System.IO.File.WriteAllBytes(DOWNLOADED_ALL_ATTACHMENTS_FOR_SIGNER1_IN_PACKAGE_ZIP, downloadedAllAttachmentsForSigner1InPackage.Contents);
// Download all attachments for the signer2 in the package
DownloadedFile downloadedAllAttachmentsForSigner2InPackage = eslClient.AttachmentRequirementService.DownloadAllAttachmentFilesForSignerInPackage(retrievedPackage, signer2);
System.IO.File.WriteAllBytes(DOWNLOADED_ALL_ATTACHMENTS_FOR_SIGNER2_IN_PACKAGE_ZIP, downloadedAllAttachmentsForSigner2InPackage.Contents);
downloadedAttachemnt1 = new FileInfo(downloadedAttachment.Filename);
}
