public void CanAddTwoAttachmentRequirement()
{
Silanis.ESL.SDK.AttachmentRequirement attachmentRequirement1 = AttachmentRequirementBuilder.NewAttachmentRequirementWithName("Driver's license")
.WithDescription("Please upload scanned driver's license.")
.IsRequiredAttachment()
.Build();
Silanis.ESL.SDK.AttachmentRequirement attachmentRequirement2 = AttachmentRequirementBuilder.NewAttachmentRequirementWithName("Medicare card")
.WithDescription("Please upload scanned medicare card.")
.IsRequiredAttachment()
.Build();
Silanis.ESL.SDK.Signer signer = SignerBuilder.NewSignerWithEmail("*****@*****.**")
.WithFirstName("Billy")
.WithLastName("Bob")
.WithAttachmentRequirement(attachmentRequirement1)
.WithAttachmentRequirement(attachmentRequirement2)
.Build();
Assert.AreEqual(signer.Attachments.Count, 2);
Assert.AreEqual(signer.GetAttachmentRequirement("Driver's license").Name, attachmentRequirement1.Name);
Assert.AreEqual(signer.GetAttachmentRequirement("Driver's license").Description, attachmentRequirement1.Description);
Assert.AreEqual(signer.GetAttachmentRequirement("Driver's license").Required, attachmentRequirement1.Required);
Assert.AreEqual(signer.GetAttachmentRequirement("Driver's license").Status, attachmentRequirement1.Status);
Assert.AreEqual(signer.GetAttachmentRequirement("Medicare card").Name, attachmentRequirement2.Name);
Assert.AreEqual(signer.GetAttachmentRequirement("Medicare card").Description, attachmentRequirement2.Description);
Assert.AreEqual(signer.GetAttachmentRequirement("Medicare card").Required, attachmentRequirement2.Required);
Assert.AreEqual(signer.GetAttachmentRequirement("Medicare card").Status.ToString(), attachmentRequirement2.Status.ToString());
}
private OneSpanSign.Sdk.AttachmentRequirement CreateTypicalSDKAttachmentRequirement()
{
OneSpanSign.Sdk.AttachmentRequirement attachmentRequirement = AttachmentRequirementBuilder.NewAttachmentRequirementWithName("Driver's license")
.WithDescription("Please upload a scanned copy of your driver's license")
.IsRequiredAttachment()
.Build();
attachmentRequirement.Id = "attachmentId";
return(attachmentRequirement);
}
override public void Execute()
{
// Signer with 1 attachment requirement
signer = SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith")
.WithCustomId(SIGNER_ID)
.WithAttachmentRequirement(AttachmentRequirementBuilder.NewAttachmentRequirementWithName(NAME)
.WithDescription(DESCRIPTION)
.IsRequiredAttachment()
.Build()).Build();
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed(PackageName)
.DescribedAs("This is a package created using the eSignLive SDK")
.WithSigner(signer)
.WithDocument(DocumentBuilder.NewDocumentNamed("test document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.Build())
.Build())
.Build();
packageId = OssClient.CreateAndSendPackage(superDuperPackage);
retrievedPackage = OssClient.GetPackage(packageId);
signerAtt = retrievedPackage.GetSigner(email1).GetAttachmentRequirement(NAME);
byte [] attachmentForSignerFileContent = new StreamDocumentSource(attachmentInputStream).Content();
signerAttachmentFileSize = attachmentForSignerFileContent.Length;
OssClient.UploadAttachment(packageId, signerAtt.Id, ATTACHMENT_FILE_NAME,
attachmentForSignerFileContent, SIGNER_ID);
retrievedPackage = OssClient.GetPackage(packageId);
signerAtt = retrievedPackage.GetSigner(email1).GetAttachmentRequirement(NAME);
filesAfterUpload = signerAtt.Files;
AttachmentFile attachmentFile = filesAfterUpload[0];
// Download signer attachment
DownloadedFile downloadedAttachment = ossClient.AttachmentRequirementService.DownloadAttachmentFile(packageId, signerAtt.Id, attachmentFile.Id);
System.IO.File.WriteAllBytes(downloadedAttachment.Filename, downloadedAttachment.Contents);
OssClient.DeleteAttachmentFile(packageId, signerAtt.Id, attachmentFile.Id, SIGNER_ID);
retrievedPackage = OssClient.GetPackage(packageId);
signerAtt = retrievedPackage.GetSigner(email1).GetAttachmentRequirement(NAME);
filesAfterDelete = signerAtt.Files;
downloadedAttachmentFile = new FileInfo(downloadedAttachment.Filename);
}
override public void Execute()
{
// Signer1 with 1 attachment requirement
signer1 = SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith")
.WithCustomId(SIGNER1ID)
.WithAttachmentRequirement(AttachmentRequirementBuilder.NewAttachmentRequirementWithName(NAME1)
.WithDescription(DESCRIPTION1)
.IsRequiredAttachment()
.Build())
.Build();
// Signer2 with 2 attachment requirements
Signer signer2 = SignerBuilder.NewSignerWithEmail(email2)
.WithFirstName("Patty")
.WithLastName("Galant")
.WithAttachmentRequirement(AttachmentRequirementBuilder.NewAttachmentRequirementWithName(NAME2)
.WithDescription(DESCRIPTION2)
.Build())
.WithAttachmentRequirement(AttachmentRequirementBuilder.NewAttachmentRequirementWithName(NAME3)
.WithDescription(DESCRIPTION3)
.IsRequiredAttachment()
.Build())
.Build();
Stream file = File.OpenRead(new FileInfo(Directory.GetCurrentDirectory() + "/src/document.pdf").FullName);
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("AttachmentRequirementExample: " + DateTime.Now)
.DescribedAs("This is a package created using the e-SignLive SDK")
.WithSigner(signer1)
.WithSigner(signer2)
.WithDocument(DocumentBuilder.NewDocumentNamed("test document")
.FromStream(file, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.Build())
.Build())
.Build();
packageId = eslClient.CreateAndSendPackage(superDuperPackage);
retrievedPackage = eslClient.GetPackage(packageId);
attachment1Id = retrievedPackage.Signers[email1].Attachments[NAME1].Id;
signer1 = retrievedPackage.Signers[email1];
// Signer1 uploads required attachment
// Sender can accept/reject the uploaded attachment
}
public void BuildWithSpecificValues()
{
string name = "Driver's license";
string description = "Please upload driver's license";
bool isRequired = true;
AttachmentRequirement attachmentRequirement = AttachmentRequirementBuilder.NewAttachmentRequirementWithName(name)
.WithDescription(description)
.IsRequiredAttachment()
.Build();
Assert.AreEqual(name, attachmentRequirement.Name);
Assert.AreEqual(description, attachmentRequirement.Description);
Assert.AreEqual(isRequired, attachmentRequirement.Required);
}
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();
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed(PackageName)
.DescribedAs("This is a package created using the eSignLive SDK")
.WithSigner(signer1)
.WithDocument(DocumentBuilder.NewDocumentNamed("test document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.Build())
.Build())
.Build();
packageId = OssClient.CreateAndSendPackage(superDuperPackage);
retrievedPackage = OssClient.GetPackage(packageId);
signer1Att1 = retrievedPackage.GetSigner(email1).GetAttachmentRequirement(NAME1);
byte [] attachment1ForSigner1FileContent = new StreamDocumentSource(attachmentInputStream1).Content();
OssClient.UploadAttachment(packageId, signer1Att1.Id, ATTACHMENT_FILE_NAME1,
attachment1ForSigner1FileContent, SIGNER1_ID);
retrievedPackage = OssClient.GetPackage(packageId);
signer1Att1 = retrievedPackage.GetSigner(email1).GetAttachmentRequirement(NAME1);
filesAfterUpload = signer1Att1.Files;
AttachmentFile attachmentFile = filesAfterUpload[0];
OssClient.DeleteAttachmentFile(packageId, signer1Att1.Id, attachmentFile.Id, SIGNER1_ID);
retrievedPackage = OssClient.GetPackage(packageId);
signer1Att1 = retrievedPackage.GetSigner(email1).GetAttachmentRequirement(NAME1);
filesAfterDelete = signer1Att1.Files;
}
private Silanis.ESL.SDK.Signer CreateTypicalSDKSigner()
{
return(SignerBuilder.NewSignerWithEmail("*****@*****.**")
.CanChangeSigner()
.DeliverSignedDocumentsByEmail()
.SigningOrder(1)
.WithCompany("ABC Inc")
.WithCustomId("1")
.WithFirstName("first name")
.WithLastName("last name")
.WithEmailMessage("Email message")
.WithTitle("Miss")
.WithAttachmentRequirement(AttachmentRequirementBuilder.NewAttachmentRequirementWithName("driver's license")
.WithDescription("Please upload your scanned driver's license")
.IsRequiredAttachment()
.Build())
.Build());
}
public void CanSetAndGetAttachmentRequirements()
{
AttachmentRequirement attachmentRequirement = AttachmentRequirementBuilder.NewAttachmentRequirementWithName("Driver's license")
.WithDescription("Please upload scanned driver's license.")
.IsRequiredAttachment()
.Build();
Signer signer = SignerBuilder.NewSignerWithEmail("*****@*****.**")
.WithFirstName("Billy")
.WithLastName("Bob")
.WithAttachmentRequirement(attachmentRequirement)
.Build();
Assert.AreEqual(signer.Attachments.Count, 1);
Assert.AreEqual(signer.GetAttachmentRequirement("Driver's license").Name, attachmentRequirement.Name);
Assert.AreEqual(signer.GetAttachmentRequirement("Driver's license").Description, attachmentRequirement.Description);
Assert.AreEqual(signer.GetAttachmentRequirement("Driver's license").Required, attachmentRequirement.Required);
Assert.AreEqual(signer.GetAttachmentRequirement("Driver's license").Status, attachmentRequirement.Status);
}
override public void Execute()
{
DocumentPackage template = PackageBuilder.NewPackageNamed("Template " + PackageName)
.DescribedAs("first message")
.WithEmailMessage(PACKAGE_EMAIL_MESSAGE)
.WithSigner(SignerBuilder.NewSignerPlaceholder(new Placeholder(PLACEHOLDER_ID)))
.WithDocument(DocumentBuilder.NewDocumentNamed(DOCUMENT_NAME)
.FromStream(fileStream1, DocumentType.PDF)
.WithId(DOCUMENT_ID)
.WithSignature(SignatureBuilder.SignatureFor(new Placeholder(PLACEHOLDER_ID))
.OnPage(0)
.AtPosition(100, 100))
.Build())
.Build();
template.Id = eslClient.CreateTemplate(template);
DocumentPackage newPackage = PackageBuilder.NewPackageNamed(PackageName)
.DescribedAs(PACKAGE_DESCRIPTION)
.WithEmailMessage(PACKAGE_EMAIL_MESSAGE2)
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName(PACKAGE_SIGNER2_FIRST)
.WithLastName(PACKAGE_SIGNER2_LAST)
.WithTitle(PACKAGE_SIGNER2_TITLE)
.WithCompany(PACKAGE_SIGNER2_COMPANY)
.WithCustomId(PLACEHOLDER_ID)
.WithAttachmentRequirement(AttachmentRequirementBuilder.NewAttachmentRequirementWithName(ATTACHMENT_REQUIREMENT_NAME)
.WithDescription(ATTACHMENT_REQUIREMENT_DESCRIPTION)
.IsRequiredAttachment()
.Build()))
.WithSettings(DocumentPackageSettingsBuilder.NewDocumentPackageSettings()
.WithInPerson()
.Build())
.Build();
packageId = eslClient.CreatePackageFromTemplate(template.Id, newPackage);
retrievedPackage = eslClient.GetPackage(packageId);
}
public SignerBuilder WithAttachmentRequirement(AttachmentRequirementBuilder builder)
{
return(WithAttachmentRequirement(builder.Build()));
}
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);
}
public void AttachmentNameCannotBeEmptyString()
{
Assert.Throws <EslException>(() => AttachmentRequirementBuilder.NewAttachmentRequirementWithName("").Build());
}
public void AttachmentNameCannotBeNull()
{
Assert.Throws <EslException>(() => AttachmentRequirementBuilder.NewAttachmentRequirementWithName(null).Build());
}
public void AttachmentNameCannotBeEmptyString()
{
AttachmentRequirementBuilder.NewAttachmentRequirementWithName("").Build();
}
public void AttachmentNameCannotBeNull()
{
AttachmentRequirementBuilder.NewAttachmentRequirementWithName(null).Build();
}
public SignerBuilder WithAttachmentRequirement (AttachmentRequirementBuilder builder)
{
return WithAttachmentRequirement(builder.Build());
}
