public void UpdateApprovals(DocumentPackage sdkPackage, string documentId, IList<Signature> signatureList)
{
Package apiPackage = new DocumentPackageConverter(sdkPackage).ToAPIPackage();
IList<Approval> approvalList = new List<Approval>();
foreach (Signature signature in signatureList)
{
Approval approval = new SignatureConverter(signature).ToAPIApproval();
if (signature.IsPlaceholderSignature())
{
approval.Role = signature.RoleId.Id;
}
else if (signature.IsGroupSignature())
{
approval.Role = FindRoleIdForGroup(signature.GroupId, apiPackage);
}
else
{
approval.Role = FindRoleIdForSigner(signature.SignerEmail, apiPackage);
}
approvalList.Add(approval);
}
apiClient.UpdateApprovals(sdkPackage.Id, documentId, approvalList);
}
override public void Execute()
{
DocumentPackage package = PackageBuilder.NewPackageNamed ("Signing Order " + DateTime.Now)
.DescribedAs ("This is a signer workflow example")
.WithSigner(SignerBuilder.NewSignerWithEmail(email2)
.WithFirstName("Coco")
.WithLastName("Beware")
.SigningOrder(2))
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith")
.SigningOrder(1))
.Build ();
packageId = eslClient.CreatePackage (package);
Console.WriteLine("Package created, id = " + packageId);
savedPackage = EslClient.GetPackage(packageId);
// Reorder signers
afterReorder = eslClient.GetPackage(packageId);
afterReorder.Signers[email2].SigningOrder = 1;
afterReorder.Signers[email1].SigningOrder = 2;
eslClient.PackageService.OrderSigners(afterReorder);
afterReorder = eslClient.GetPackage(packageId);
Console.WriteLine("Signer order changed");
}
override public void Execute()
{
senderEmail = System.Guid.NewGuid().ToString() + "@e-signlive.com";
senderEmail = senderEmail.Replace("-", "");
eslClient.AccountService.InviteUser(
AccountMemberBuilder.NewAccountMember(senderEmail)
.WithFirstName("firstName")
.WithLastName("lastName")
.WithCompany("company")
.WithTitle("title")
.WithLanguage( "language" )
.WithPhoneNumber( "phoneNumber" )
.Build()
);
SenderInfo senderInfo = SenderInfoBuilder.NewSenderInfo(senderEmail)
.WithName(SENDER_FIRST_NAME, SENDER_SECOND_NAME)
.WithTitle(SENDER_TITLE)
.WithCompany(SENDER_COMPANY)
.Build();
package = PackageBuilder.NewPackageNamed( "CustomSenderInfoExample " + DateTime.Now )
.WithSenderInfo( senderInfo )
.DescribedAs( "This is a package created using the e-SignLive SDK" )
.ExpiresOn( DateTime.Now.AddMonths(1) )
.WithEmailMessage( "This message should be delivered to all signers" )
.Build();
packageId = eslClient.CreatePackage( package );
}
private Silanis.ESL.SDK.DocumentPackage CreateTypicalSDKDocumentPackage()
{
Silanis.ESL.SDK.DocumentPackage sdkDocumentPackage = PackageBuilder.NewPackageNamed("SDK Package Name")
.DescribedAs("typical description")
.WithEmailMessage("typical email message")
.WithLanguage(CultureInfo.GetCultureInfo("en"))
.Build();
return(sdkDocumentPackage);
}
/// <summary>
/// Create a document layout from an already created DocumentPackage. Will only save document fields for one document
/// in the package.
/// </summary>
/// <returns>The layout id.</returns>
/// <param name="layout">The DocumentPackage with one document from which to create layout.</param>
public string CreateLayout(DocumentPackage layout)
{
Package layoutToCreate = new DocumentPackageConverter(layout).ToAPIPackage();
foreach (Silanis.ESL.SDK.Document document in layout.Documents.Values)
{
layoutToCreate.AddDocument(new DocumentConverter(document).ToAPIDocument(layoutToCreate));
}
return apiClient.CreateLayout(layoutToCreate, layout.Id.Id);
}
private Document getAddedDocument(DocumentPackage documentPackage, string documentName)
{
foreach (Document document in documentPackage.Documents.Values)
{
if (document.Name.Equals(documentName))
{
return document;
}
}
return null;
}
public PackageId CreatePackage (DocumentPackage package)
{
Silanis.ESL.API.Package packageToCreate = package.ToAPIPackage ();
PackageId id = packageService.CreatePackage (packageToCreate);
foreach (Document document in package.Documents.Values)
{
packageService.UploadDocument (id, document.FileName, document.Content, document.ToAPIDocument (packageToCreate));
}
return id;
}
public void ConvertSDKToAPI()
{
sdkPackage1 = CreateTypicalSDKDocumentPackage();
apiPackage1 = new DocumentPackageConverter(sdkPackage1).ToAPIPackage();
Assert.IsNotNull(apiPackage1);
Assert.AreEqual(apiPackage1.Id, sdkPackage1.Id.ToString());
Assert.AreEqual(apiPackage1.Name, sdkPackage1.Name);
Assert.AreEqual(apiPackage1.Description, sdkPackage1.Description);
Assert.AreEqual(apiPackage1.EmailMessage, sdkPackage1.EmailMessage);
Assert.AreEqual(apiPackage1.Language, sdkPackage1.Language.ToString());
Assert.AreEqual(apiPackage1.Due, sdkPackage1.ExpiryDate);
Assert.AreEqual(apiPackage1.Status, sdkPackage1.Status.getApiValue());
}
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.Signers[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 ConvertSDKToAPI()
{
sdkPackage1 = CreateTypicalSDKDocumentPackage();
apiPackage1 = new DocumentPackageConverter(sdkPackage1).ToAPIPackage();
Assert.IsNotNull(apiPackage1);
Assert.AreEqual(apiPackage1.Name, sdkPackage1.Name);
Assert.AreEqual(apiPackage1.Description, sdkPackage1.Description);
Assert.AreEqual(apiPackage1.Id, sdkPackage1.Id);
Assert.AreEqual(apiPackage1.EmailMessage, sdkPackage1.EmailMessage);
Assert.AreEqual(apiPackage1.Language, sdkPackage1.Language.ToString());
Assert.AreEqual(apiPackage1.Due, sdkPackage1.ExpiryDate);
Assert.AreEqual(apiPackage1.Status.ToString(), sdkPackage1.Status.ToString());
}
override public void Execute()
{
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed( "TextAnchorExtractionExample: " + DateTime.Now )
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName( "John" )
.WithLastName( "Smith" ) )
.WithDocument( DocumentBuilder.NewDocumentNamed( "First Document" )
.FromStream( fileStream1, DocumentType.PDF )
.WithSignature(SignatureBuilder.SignatureFor(email1)
.WithPositionAnchor(TextAnchorBuilder.NewTextAnchor("Nondisclosure")
.AtPosition(TextAnchorPosition.BOTTOMRIGHT)
.WithSize(FieldWidth, FieldHeight)
.WithOffset(0, 0)
.WithCharacter(9)
.WithOccurrence(0)))
.WithSignature(SignatureBuilder.SignatureFor(email1)
.WithPositionAnchor(TextAnchorBuilder.NewTextAnchor("Receiving")
.AtPosition(TextAnchorPosition.TOPLEFT)
.WithSize(FieldWidth, FieldHeight)
.WithOffset(0, 0)
.WithCharacter(0)
.WithOccurrence(0))
.WithField(FieldBuilder.TextField()
.WithPositionAnchor(TextAnchorBuilder.NewTextAnchor("Definition")
.AtPosition(TextAnchorPosition.TOPLEFT)
.WithSize(FieldWidth, FieldHeight)
.WithOffset(0, 0)
.WithCharacter(0)
.WithOccurrence(0)))
.WithField(FieldBuilder.TextField()
.WithPositionAnchor(TextAnchorBuilder.NewTextAnchor("through legitimate means")
.AtPosition(TextAnchorPosition.TOPLEFT)
.WithSize(FieldWidth, FieldHeight)
.WithOffset(100, 100)
.WithCharacter(0)
.WithOccurrence(1))))
)
.Build();
PackageId packageId = eslClient.CreatePackage( superDuperPackage );
eslClient.SendPackage( packageId );
retrievedPackage = eslClient.GetPackage(packageId);
Console.Out.WriteLine(packageId.Id);
}
public void ModifyApproval(DocumentPackage sdkPackage, string documentId, Signature signature)
{
Approval approval = new SignatureConverter(signature).ToAPIApproval();
Package apiPackage = new DocumentPackageConverter(sdkPackage).ToAPIPackage();
if (signature.IsPlaceholderSignature())
{
approval.Role = signature.RoleId.Id;
}
else if (signature.IsGroupSignature())
{
approval.Role = FindRoleIdForGroup(signature.GroupId, apiPackage);
}
else
{
approval.Role = FindRoleIdForSigner(signature.SignerEmail, apiPackage);
}
apiClient.ModifyApproval(sdkPackage.Id, documentId, approval);
}
public void ConvertAPIToSDK()
{
apiPackage1 = CreateTypicalAPIPackage();
sdkPackage1 = new DocumentPackageConverter(apiPackage1).ToSDKPackage();
Assert.IsNotNull(sdkPackage1);
Assert.AreEqual(apiPackage1.Id, sdkPackage1.Id.Id);
Assert.AreEqual(apiPackage1.Autocomplete, sdkPackage1.Autocomplete);
Assert.AreEqual(apiPackage1.Description, sdkPackage1.Description);
Assert.AreEqual(apiPackage1.Due, sdkPackage1.ExpiryDate);
Assert.AreEqual(apiPackage1.Status.ToString(), sdkPackage1.Status.ToString());
Assert.AreEqual(apiPackage1.Name, sdkPackage1.Name);
Assert.AreEqual(apiPackage1.Messages[0].Content, sdkPackage1.Messages[0].Content);
Assert.AreEqual(apiPackage1.Messages[0].Created, sdkPackage1.Messages[0].Created);
Assert.AreEqual(apiPackage1.Messages[0].Status.ToString(), sdkPackage1.Messages[0].Status.ToString());
Assert.AreEqual(apiPackage1.Messages[0].From.FirstName, sdkPackage1.Messages[0].From.FirstName);
Assert.AreEqual(apiPackage1.Messages[0].From.LastName, sdkPackage1.Messages[0].From.LastName);
Assert.AreEqual(apiPackage1.Messages[0].From.Email, sdkPackage1.Messages[0].From.Email);
Assert.AreEqual(apiPackage1.Messages[0].To[0].FirstName, sdkPackage1.Messages[0].To["*****@*****.**"].FirstName);
Assert.AreEqual(apiPackage1.Messages[0].To[0].LastName, sdkPackage1.Messages[0].To["*****@*****.**"].LastName);
Assert.AreEqual(apiPackage1.Messages[0].To[0].Email, sdkPackage1.Messages[0].To["*****@*****.**"].Email);
}
public PackageId CreatePackage(DocumentPackage package)
{
ValidateSignatures(package);
if (!IsSdkVersionSetInPackageData(package))
{
SetSdkVersionInPackageData(package);
}
Silanis.ESL.API.Package packageToCreate = new DocumentPackageConverter(package).ToAPIPackage();
PackageId id = packageService.CreatePackage(packageToCreate);
try
{
UploadDocuments(id, package.Documents);
}
catch (Exception e)
{
packageService.DeletePackage(id);
throw new EslException("Could not create a new package." + " Exception: " + e.Message, e);
}
return(id);
}
public void ConvertAPIToSDK()
{
apiPackage1 = CreateTypicalAPIPackage();
sdkPackage1 = new DocumentPackageConverter(apiPackage1).ToSDKPackage();
Assert.IsNotNull(sdkPackage1);
Assert.AreEqual(apiPackage1.Id, sdkPackage1.Id.Id);
Assert.AreEqual(apiPackage1.Autocomplete, sdkPackage1.Autocomplete);
Assert.AreEqual(apiPackage1.Description, sdkPackage1.Description);
Assert.AreEqual(apiPackage1.Due, sdkPackage1.ExpiryDate);
Assert.AreEqual(apiPackage1.Status.ToString(), sdkPackage1.Status.ToString());
Assert.AreEqual(apiPackage1.Name, sdkPackage1.Name);
Assert.AreEqual(apiPackage1.Messages[0].Content, sdkPackage1.Messages[0].Content);
Assert.AreEqual(apiPackage1.Messages[0].Created, sdkPackage1.Messages[0].Created);
Assert.AreEqual(apiPackage1.Messages[0].Status.ToString(), sdkPackage1.Messages[0].Status.ToString());
Assert.AreEqual(apiPackage1.Messages[0].From.FirstName, sdkPackage1.Messages[0].From.FirstName);
Assert.AreEqual(apiPackage1.Messages[0].From.LastName, sdkPackage1.Messages[0].From.LastName);
Assert.AreEqual(apiPackage1.Messages[0].From.Email, sdkPackage1.Messages[0].From.Email);
Assert.AreEqual(apiPackage1.Messages[0].To[0].FirstName, sdkPackage1.Messages[0].To["*****@*****.**"].FirstName);
Assert.AreEqual(apiPackage1.Messages[0].To[0].LastName, sdkPackage1.Messages[0].To["*****@*****.**"].LastName);
Assert.AreEqual(apiPackage1.Messages[0].To[0].Email, sdkPackage1.Messages[0].To["*****@*****.**"].Email);
}
private void SetNewSignersIndexIfRoleWorkflowEnabled(PackageId templateId, DocumentPackage documentPackage)
{
DocumentPackage template = new DocumentPackageConverter(packageService.GetPackage(templateId)).ToSDKPackage();
if (CheckSignerOrdering(template))
{
int firstSignerIndex = GetMaxSigningOrder(template, documentPackage) + 1;
foreach (Signer signer in documentPackage.Signers)
{
Signer templatePlaceholder = template.GetPlaceholder(signer.Id);
if (templatePlaceholder != null)
{
signer.SigningOrder = templatePlaceholder.SigningOrder;
}
if (signer.SigningOrder <= 0)
{
signer.SigningOrder = firstSignerIndex;
firstSignerIndex++;
}
}
}
}
override public void Execute()
{
senderEmail = System.Guid.NewGuid().ToString().Replace("-","") + "@e-signlive.com";
eslClient.AccountService.InviteUser(
AccountMemberBuilder.NewAccountMember(senderEmail)
.WithFirstName("firstName")
.WithLastName("lastName")
.WithCompany("company")
.WithTitle("title")
.WithLanguage( "fr" )
.WithPhoneNumber( "phoneNumber" )
.WithStatus(SenderStatus.ACTIVE)
.Build()
);
SenderInfo senderInfo = SenderInfoBuilder.NewSenderInfo(senderEmail)
.WithName(SENDER_FIRST_NAME, SENDER_SECOND_NAME)
.WithTitle(SENDER_TITLE)
.WithCompany(SENDER_COMPANY)
.Build();
package = PackageBuilder.NewPackageNamed( "CustomSenderInfoExample " + DateTime.Now )
.WithSenderInfo( senderInfo )
.DescribedAs( "This is a package created using the e-SignLive SDK" )
.ExpiresOn( DateTime.Now.AddMonths(1) )
.WithEmailMessage( "This message should be delivered to all signers" )
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithId("doc1"))
.Build();
packageId = eslClient.CreatePackage( package );
eslClient.DownloadDocument(packageId, "doc1");
Console.WriteLine("Downloaded document");
}
public Document UploadDocument(Document document, DocumentPackage documentPackage)
{
return(UploadDocument(document.FileName, document.Content, document, documentPackage));
}
public PackageId CreateTemplateFromPackage(PackageId originalPackageId, string templateName)
{
DocumentPackage sdkPackage = PackageBuilder.NewPackageNamed(templateName).Build();
return(CreateTemplateFromPackage(originalPackageId, sdkPackage));
}
public PackageId CreatePackageFromTemplate(PackageId templateId, DocumentPackage delta)
{
ValidateSignatures(delta);
SetNewSignersIndexIfRoleWorkflowEnabled(templateId, delta);
return(templateService.CreatePackageFromTemplate(templateId, new DocumentPackageConverter(delta).ToAPIPackage()));
}
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
}
override public void Execute()
{
DocumentPackage superDuperPackage =
PackageBuilder.NewPackageNamed("FieldManipulationExample: " + DateTime.Now)
.DescribedAs("This is a package created using the e-SignLive SDK")
.ExpiresOn(DateTime.Now.AddMonths(100))
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithCustomId("signatureId1")
.WithFirstName("firstName1")
.WithLastName("lastName1"))
.WithDocument(DocumentBuilder.NewDocumentNamed("FieldManipulationExample")
.WithId("documentId")
.FromStream(fileStream, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.WithId(signatureId)
.AtPosition(100, 100))
)
.Build();
packageId = eslClient.CreatePackage(superDuperPackage);
field1 = FieldBuilder.RadioButton("group1")
.WithName("field1")
.WithId("fieldId1")
.AtPosition(400, 100)
.OnPage(0)
.Build();
field2 = FieldBuilder.RadioButton("group1")
.WithName("field2")
.WithId("fieldId2")
.AtPosition(400, 200)
.OnPage(0)
.Build();
field3 = FieldBuilder.RadioButton("group1")
.WithName("field3")
.WithId("fieldId3")
.AtPosition(400, 300)
.OnPage(0)
.Build();
updatedField = FieldBuilder.RadioButton("group1")
.WithName("updatedField")
.WithId("fieldId3")
.AtPosition(400, 300)
.OnPage(0)
.Build();
// Adding the fields
eslClient.ApprovalService.AddField(packageId, documentId, signatureId, field1);
eslClient.ApprovalService.AddField(packageId, documentId, signatureId, field2);
eslClient.ApprovalService.AddField(packageId, documentId, signatureId, field3);
createdPackage = eslClient.GetPackage(packageId);
addedFields = eslClient.ApprovalService.GetApproval(createdPackage, documentId, signatureId.Id).Fields;
// Deleting field1
eslClient.ApprovalService.DeleteField(packageId, documentId, signatureId, field1.Id);
createdPackage = eslClient.GetPackage(packageId);
deletedFields = eslClient.ApprovalService.GetApproval(createdPackage, documentId, signatureId.Id).Fields;
// Updating the information for the third field
eslClient.ApprovalService.ModifyField(packageId, documentId, signatureId, updatedField);
createdPackage = eslClient.GetPackage(packageId);
updatedFields = eslClient.ApprovalService.GetApproval(createdPackage, documentId, signatureId.Id).Fields;
}
/// <summary>
/// Sender downloads the attachment.
/// </summary>
/// <returns>The attachment.</returns>
/// <param name="packageId">Package identifier.</param>
/// <param name="attachmentId">Attachment identifier.</param>
public byte[] DownloadAllAttachmentsForSignerInPackage(DocumentPackage sdkPackage, Signer signer)
{
return(apiClient.DownloadAllAttachmentsForSignerInPackage(sdkPackage, signer));
}
/// <summary>
/// Sender downloads all attachment files for the signer in the package.
/// </summary>
/// <returns>The attachment files with file name.</returns>
/// <param name="packageId">Package identifier.</param>
/// <param name="signer">Signer.</param>
public DownloadedFile DownloadAllAttachmentFilesForSignerInPackage(DocumentPackage sdkPackage, Signer signer)
{
return(apiClient.DownloadAllAttachmentFilesForSignerInPackage(sdkPackage, signer));
}
internal bool IsSdkVersionSetInPackageData(DocumentPackage package)
{
if (package.Attributes != null && package.Attributes.Contents.ContainsKey("sdk"))
{
return true;
}
return false;
}
public PackageId CreatePackage(DocumentPackage package)
{
if (!IsSdkVersionSetInPackageData(package))
{
SetSdkVersionInPackageData(package);
}
Silanis.ESL.API.Package packageToCreate = new DocumentPackageConverter(package).ToAPIPackage();
PackageId id = packageService.CreatePackage (packageToCreate);
DocumentPackage retrievedPackage = GetPackage(id);
foreach (Document document in package.Documents.Values)
{
UploadDocument(document, retrievedPackage);
}
return id;
}
public Document UploadDocument(Document document, DocumentPackage documentPackage ) {
return UploadDocument( document.FileName, document.Content, document, documentPackage );
}
public Document UploadDocument(String fileName, byte[] fileContent, Document document, DocumentPackage documentPackage)
{
Document uploaded = packageService.UploadDocument(documentPackage, fileName, fileContent, document);
documentPackage.Documents[uploaded.Name] = uploaded;
return uploaded;
}
public void UpdatePackage(Silanis.ESL.SDK.PackageId packageId, DocumentPackage sentSettings)
{
packageService.UpdatePackage( packageId, new DocumentPackageConverter(sentSettings).ToAPIPackage() );
}
public PackageId CreateTemplate(DocumentPackage template)
{
PackageId templateId = templateService.CreateTemplate(new DocumentPackageConverter(template).ToAPIPackage());
DocumentPackage createdTemplate = GetPackage(templateId);
foreach (Document document in template.Documents.Values)
{
UploadDocument(document, createdTemplate);
}
return templateId;
}
public PackageId CreatePackageFromTemplate(PackageId templateId, DocumentPackage delta)
{
return templateService.CreatePackageFromTemplate( templateId, new DocumentPackageConverter(delta).ToAPIPackage() );
}
public Document UploadDocument(Document document, PackageId packageId)
{
DocumentPackage documentPackage = GetPackage(packageId);
return(UploadDocument(document, documentPackage));
}
override public void Execute()
{
// Create a package with one document and one signature with two fields
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed(LAYOUT_PACKAGE_NAME)
.DescribedAs(LAYOUT_PACKAGE_DESCRIPTION)
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithCustomId("Client1")
.WithFirstName("John")
.WithLastName("Smith")
.WithTitle("Managing Director")
.WithCompany("Acme Inc."))
.WithDocument(DocumentBuilder.NewDocumentNamed(LAYOUT_DOCUMENT_NAME)
.WithId("documentId")
.WithDescription("Layout document description")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(100, 100)
.WithField(FieldBuilder.SignerTitle()
.WithName(FIELD_1_NAME)
.OnPage(0)
.AtPosition(100, 200))
.WithField(FieldBuilder.SignerCompany()
.WithName(FIELD_2_NAME)
.OnPage(0)
.AtPosition(100, 300))))
.Build();
PackageId packageId1 = eslClient.CreatePackage(superDuperPackage);
superDuperPackage.Id = packageId1;
// Create layout from package
layoutId = eslClient.LayoutService.CreateLayout(superDuperPackage);
// Get a list of layouts
layouts = eslClient.LayoutService.GetLayouts(Direction.ASCENDING, new PageRequest(1, 100));
// Create a new package to apply document layout to
DocumentPackage packageFromLayout = PackageBuilder.NewPackageNamed("DocumentLayoutExample " + DateTime.Now)
.DescribedAs("This is a package created using the e-SignLive SDK")
.WithEmailMessage("This message should be delivered to all signers")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithCustomId("Client1")
.WithFirstName("John")
.WithLastName("Smith")
.WithTitle("Managing Director")
.WithCompany("Acme Inc."))
.WithDocument(DocumentBuilder.NewDocumentNamed(APPLY_LAYOUT_DOCUMENT_NAME)
.WithId(APPLY_LAYOUT_DOCUMENT_ID)
.WithDescription(APPLY_LAYOUT_DOCUMENT_DESCRIPTION)
.FromStream(fileStream2, DocumentType.PDF))
.Build();
packageId = eslClient.CreatePackage(packageFromLayout);
// Apply the layout to document in package
eslClient.LayoutService.ApplyLayout(packageId, APPLY_LAYOUT_DOCUMENT_ID, layoutId);
packageWithLayout = eslClient.GetPackage(packageId);
}
public PackageId CreateTemplateFromPackage(PackageId originalPackageId, DocumentPackage delta)
{
return templateService.CreateTemplateFromPackage( originalPackageId, new DocumentPackageConverter(delta).ToAPIPackage() );
}
override public void Execute()
{
DocumentPackage superDuperPackage =
PackageBuilder.NewPackageNamed("SignatureManipulationExample: " + DateTime.Now)
.DescribedAs("This is a package created using the e-SignLive SDK")
.ExpiresOn(DateTime.Now.AddMonths(100))
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithCustomId("signatureId1")
.WithFirstName("firstName1")
.WithLastName("lastName1")
)
.WithSigner(SignerBuilder.NewSignerWithEmail(email2)
.WithCustomId("signatureId2")
.WithFirstName("firstName2")
.WithLastName("lastName2")
)
.WithSigner(SignerBuilder.NewSignerWithEmail(email3)
.WithCustomId("signatureId3")
.WithFirstName("firstName3")
.WithLastName("lastName3")
)
.WithDocument(DocumentBuilder.NewDocumentNamed(DOCUMENT_NAME)
.WithId("documentId")
.FromStream(fileStream, DocumentType.PDF)
)
.Build();
packageId = eslClient.CreatePackage(superDuperPackage);
signature1 = SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.WithId(new SignatureId("signatureId1"))
.AtPosition(100, 100)
.Build();
signature2 = SignatureBuilder.SignatureFor(email2)
.OnPage(0)
.WithId(new SignatureId("signatureId2"))
.AtPosition(100, 200)
.Build();
signature3 = SignatureBuilder.SignatureFor(email3)
.OnPage(0)
.WithId(new SignatureId("signatureId3"))
.AtPosition(100, 300)
.Build();
modifiedSignature = SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.WithId(new SignatureId("signatureId3"))
.AtPosition(200, 400)
.Build();
// Adding the signatures
createdPackage = eslClient.GetPackage(packageId);
eslClient.ApprovalService.AddApproval(createdPackage, documentId, signature1);
eslClient.ApprovalService.AddApproval(createdPackage, documentId, signature2);
eslClient.ApprovalService.AddApproval(createdPackage, documentId, signature3);
addedSignatures = eslClient.GetPackage(packageId).Documents[DOCUMENT_NAME].Signatures;
// Deleting signature for signer 1
eslClient.ApprovalService.DeleteApproval(packageId, "documentId", "signatureId1");
deletedSignatures = eslClient.GetPackage(packageId).Documents[DOCUMENT_NAME].Signatures;
// Updating the information for the third signature
createdPackage = eslClient.GetPackage(packageId);
eslClient.ApprovalService.ModifyApproval(createdPackage, "documentId", modifiedSignature);
modifiedSignatures = eslClient.GetPackage(packageId).Documents[DOCUMENT_NAME].Signatures;
// Update all the signatures in the document with the provided list of signatures
updatedSignature1 = SignatureBuilder.SignatureFor(email2)
.OnPage(0)
.AtPosition(300, 300)
.WithId(new SignatureId("signatureId2"))
.WithField(FieldBuilder.SignerName()
.AtPosition(100, 100)
.OnPage(0))
.Build();
updatedSignature2 = SignatureBuilder.SignatureFor(email3)
.OnPage(0)
.AtPosition(300, 500)
.WithId(new SignatureId("signatureId3"))
.Build();
List<Signature> signatureList = new List<Signature>();
signatureList.Add(updatedSignature1);
signatureList.Add(updatedSignature2);
eslClient.ApprovalService.UpdateApprovals(createdPackage, documentId, signatureList);
updatedSignatures = eslClient.GetPackage(packageId).Documents[DOCUMENT_NAME].Signatures;
}
public Document UploadDocument(string fileName, byte[] fileContent, Document document, DocumentPackage documentPackage)
{
return(UploadDocument(fileName, fileContent, document, documentPackage.Id));
}
override public void Execute()
{
FileInfo file = new FileInfo(Directory.GetCurrentDirectory() + "/src/document.pdf");
// 1. Create a package
BuiltPackage = PackageBuilder.NewPackageNamed("Policy " + DateTime.Now)
.DescribedAs("This is a package demonstrating document upload")
.WithSigner(SignerBuilder.NewSignerWithEmail("*****@*****.**")
.WithFirstName("John")
.WithLastName("Smith")
.WithTitle("Managing Director")
.WithCompany("Acme Inc."))
.Build();
PackageId packageId = eslClient.CreatePackage(BuiltPackage);
Console.WriteLine("package created, id = " + packageId);
RetrievedPackage = eslClient.GetPackage(packageId);
// 2. Construct a document
Signature signature = SignatureBuilder.SignatureFor("*****@*****.**")
.OnPage(0)
.AtPosition(100,100)
.Build();
Document document = DocumentBuilder.NewDocumentNamed( OriginalDocumentName )
.WithDescription( OriginalDocumentDescription )
.FromFile(file.FullName)
.WithSignature(signature)
.Build();
// 3. Attach the document to the created package by uploading the document.
document = eslClient.UploadDocument(document, RetrievedPackage);
Console.WriteLine("Document was uploaded");
RetrievedPackageWithNewDocument = eslClient.GetPackage(packageId);
//This is how you would update and get a document's metadata (name, description, approvals, fields)
document.Name = UpdatedDocumentName;
document.Description = UpdatedDocumentDescription;
document.Signatures.Add(SignatureBuilder.SignatureFor("*****@*****.**")
.OnPage(0)
.AtPosition(200,200)
.Build());
eslClient.PackageService.UpdateDocumentMetadata(RetrievedPackage, document);
Console.WriteLine("Document was updated");
RetrievedUpdatedDocument = eslClient.PackageService.GetDocumentMetadata(RetrievedPackage, document.Id);
RetrievedPackageWithUpdatedDocument = eslClient.GetPackage(packageId);
//This is how you would delete a document from a package
eslClient.PackageService.DeleteDocument(packageId, document.Id);
RetrievedPackageWithDeletedDocument = eslClient.GetPackage(packageId);
}
public void UploadDocument(String fileName, byte[] fileContent, Document document, DocumentPackage documentPackage)
{
Silanis.ESL.API.Package packageToCreate = documentPackage.ToAPIPackage();
packageService.UploadDocument(documentPackage.Id, fileName, fileContent, document.ToAPIDocument(packageToCreate));
}
public PackageId CreatePackageFromTemplate(PackageId templateId, DocumentPackage delta)
{
return(templateService.CreatePackageFromTemplate(templateId, new DocumentPackageConverter(delta).ToAPIPackage()));
}
public PackageId CreateAndSendPackage( DocumentPackage package )
{
PackageId packageId = CreatePackage (package);
SendPackage (packageId);
return packageId;
}
override public void Execute()
{
sentLayoutSettings = CeremonyLayoutSettingsBuilder.NewCeremonyLayoutSettings()
.WithBreadCrumbs()
.WithGlobalConfirmButton()
.WithGlobalDownloadButton()
.WithGlobalNavigation()
.WithGlobalSaveAsLayoutButton()
.WithIFrame()
.WithLogoImageLink( "old logo image link" )
.WithLogoImageSource( "old logo image source" )
.WithNavigator()
.WithProgressBar()
.WithSessionBar()
.WithTitle()
.Build();
sentSettings = DocumentPackageSettingsBuilder.NewDocumentPackageSettings()
.WithCaptureText()
.WithDecline()
.WithDialogOnComplete()
.WithDocumentToolbarDownloadButton()
.WithHandOverLinkHref("http://www.old.ca")
.WithHandOverLinkText("old hand over link text")
.WithHandOverLinkTooltip("old hand over link tool tip")
.WithInPerson()
.WithOptOut()
.WithOptOutReason("old opt out reason #1")
.WithOptOutReason("old opt out reason #2")
.WithOptOutReason("old opt out reason #3")
.WithWatermark()
.WithCeremonyLayoutSettings(sentLayoutSettings)
.Build();
sentPackage = PackageBuilder.NewPackageNamed("Old Package Name")
.DescribedAs("Old Description")
.WithEmailMessage("Old Email Message")
.ExpiresOn(DateTime.Now.AddMonths(1))
.WithLanguage( CultureInfo.GetCultureInfo("en"))
.WithAutomaticCompletion()
.WithSettings( sentSettings )
.Build();
packageId = eslClient.CreatePackage(sentPackage);
updatedLayoutSettings = CeremonyLayoutSettingsBuilder.NewCeremonyLayoutSettings()
.WithoutBreadCrumbs()
.WithoutGlobalConfirmButton()
.WithoutGlobalDownloadButton()
.WithoutGlobalNavigation()
.WithoutGlobalSaveAsLayoutButton()
.WithoutIFrame()
.WithLogoImageLink( "new logo image link" )
.WithLogoImageSource( "new logo image source" )
.WithoutNavigator()
.WithoutProgressBar()
.WithoutSessionBar()
.WithoutTitle()
.Build();
updatedSettings = DocumentPackageSettingsBuilder.NewDocumentPackageSettings()
.WithoutCaptureText()
.WithoutDecline()
.WithoutDialogOnComplete()
.WithoutDocumentToolbarDownloadButton()
.WithHandOverLinkHref("http://www.new.ca")
.WithHandOverLinkText("new hand over link text")
.WithHandOverLinkTooltip("new hand over link tool tip")
.WithoutInPerson()
.WithoutOptOut()
.WithOptOutReason("new opt out reason #1")
.WithOptOutReason("new opt out reason #2")
.WithOptOutReason("new opt out reason #3")
.WithoutWatermark()
.WithCeremonyLayoutSettings(updatedLayoutSettings)
.Build();
updatedPackage = PackageBuilder.NewPackageNamed( "New Package Name" )
.WithEmailMessage( "New Email Message" )
.ExpiresOn(DateTime.Now.AddMonths(2))
.WithLanguage( CultureInfo.GetCultureInfo("fr"))
.WithoutAutomaticCompletion()
.WithSettings( updatedSettings )
.Build();
eslClient.UpdatePackage(packageId, updatedPackage);
retrievedPackage = eslClient.GetPackage( packageId );
retrievedSettings = retrievedPackage.Settings;
retrievedLayoutSettings = retrievedSettings.CeremonyLayoutSettings;
}
public PackageId CreateTemplateFromPackage(PackageId originalPackageId, DocumentPackage delta)
{
return(templateService.CreateTemplateFromPackage(originalPackageId, new DocumentPackageConverter(delta).ToAPIPackage()));
}
public byte[] DownloadAllAttachmentsForSignerInPackage(DocumentPackage sdkPackage, Signer signer)
{
return(DownloadAllAttachmentFilesForSignerInPackage(sdkPackage, signer).Contents);
}
public PackageId CreatePackageFromTemplate(PackageId templateId, string packageName)
{
DocumentPackage sdkPackage = PackageBuilder.NewPackageNamed(packageName).Build();
return(CreatePackageFromTemplate(templateId, sdkPackage));
}
internal void SetSdkVersionInPackageData(DocumentPackage package)
{
if (package.Attributes == null)
{
package.Attributes = new DocumentPackageAttributes();
}
package.Attributes.Append( "sdk", ".NET v" + CurrentVersion );
}
public void UpdatePackage(Silanis.ESL.SDK.PackageId packageId, DocumentPackage sentSettings)
{
packageService.UpdatePackage(packageId, new DocumentPackageConverter(sentSettings).ToAPIPackage());
}
public void ConvertNullSDKToAPI()
{
sdkPackage1 = null;
converter = new DocumentPackageConverter(sdkPackage1);
Assert.IsNull(converter.ToAPIPackage());
}
public Document UploadDocument(String fileName, byte[] fileContent, Document document, DocumentPackage documentPackage)
{
Document uploaded = packageService.UploadDocument(documentPackage, fileName, fileContent, document);
documentPackage.Documents[uploaded.Name] = uploaded;
return(uploaded);
}
public void UploadDocument(String fileName, byte[] fileContent, Document document, DocumentPackage documentPackage)
{
Silanis.ESL.API.Package packageToCreate = documentPackage.ToAPIPackage();
packageService.UploadDocument(documentPackage.Id, fileName, fileContent, document.ToAPIDocument(packageToCreate));
}
internal Silanis.ESL.SDK.DocumentPackage ToSDKPackage()
{
if (apiPackage == null)
{
return(sdkPackage);
}
PackageBuilder packageBuilder = PackageBuilder.NewPackageNamed(apiPackage.Name);
packageBuilder.WithID(new PackageId(apiPackage.Id));
if (apiPackage.Autocomplete.Value)
{
packageBuilder.WithAutomaticCompletion();
}
else
{
packageBuilder.WithoutAutomaticCompletion();
}
packageBuilder.ExpiresOn(apiPackage.Due);
packageBuilder.WithStatus(new PackageStatusConverter(apiPackage.Status).ToSDKPackageStatus());
if (apiPackage.Description != null)
{
packageBuilder.DescribedAs(apiPackage.Description);
}
if (apiPackage.EmailMessage != null)
{
packageBuilder.WithEmailMessage(apiPackage.EmailMessage);
}
if (apiPackage.Language != null)
{
packageBuilder.WithLanguage(new CultureInfo(apiPackage.Language));
}
if (apiPackage.Settings != null)
{
packageBuilder.WithSettings(new DocumentPackageSettingsConverter(apiPackage.Settings).toSDKDocumentPackageSettings());
}
if (apiPackage.Sender != null)
{
packageBuilder.WithSenderInfo(new SenderConverter(apiPackage.Sender).ToSDKSenderInfo());
}
if (apiPackage.Notarized != null)
{
packageBuilder.WithNotarized(apiPackage.Notarized);
}
if (apiPackage.Visibility != null)
{
packageBuilder.WithVisibility(new VisibilityConverter(apiPackage.Visibility).ToSDKVisibility());
}
packageBuilder.WithAttributes(new DocumentPackageAttributesBuilder(apiPackage.Data).Build());
foreach (Silanis.ESL.API.Role role in apiPackage.Roles)
{
if (role.Signers.Count == 0)
{
packageBuilder.WithSigner(SignerBuilder.NewSignerPlaceholder(new Placeholder(role.Id)));
}
else if (role.Signers[0].Group != null)
{
packageBuilder.WithSigner(SignerBuilder.NewSignerFromGroup(new GroupId(role.Signers[0].Group.Id)));
}
else
{
packageBuilder.WithSigner(new SignerConverter(role).ToSDKSigner());
// The custom sender information is stored in the role.signer object.
if ("SENDER".Equals(role.Type))
{
// Override sender info with the customized ones.
Silanis.ESL.SDK.SenderInfo senderInfo = new Silanis.ESL.SDK.SenderInfo();
Silanis.ESL.API.Signer signer = role.Signers[0];
senderInfo.FirstName = signer.FirstName;
senderInfo.LastName = signer.LastName;
senderInfo.Title = signer.Title;
senderInfo.Company = signer.Company;
senderInfo.Email = signer.Email;
packageBuilder.WithSenderInfo(senderInfo);
}
}
}
foreach (Silanis.ESL.API.Document apiDocument in apiPackage.Documents)
{
Document document = new DocumentConverter(apiDocument, apiPackage).ToSDKDocument();
packageBuilder.WithDocument(document);
}
DocumentPackage documentPackage = packageBuilder.Build();
IList <Message> messages = new List <Message>();
foreach (Silanis.ESL.API.Message apiMessage in apiPackage.Messages)
{
messages.Add(new MessageConverter(apiMessage).ToSDKMessage());
}
documentPackage.Messages = messages;
if (apiPackage.Updated != null)
{
documentPackage.UpdatedDate = apiPackage.Updated;
}
return(documentPackage);
}
public PackageId CreatePackageOneStep(DocumentPackage package)
{
if (!IsSdkVersionSetInPackageData(package))
{
SetSdkVersionInPackageData(package);
}
Silanis.ESL.API.Package packageToCreate = new DocumentPackageConverter(package).ToAPIPackage();
foreach(Silanis.ESL.SDK.Document document in package.Documents.Values){
packageToCreate.AddDocument(new DocumentConverter(document).ToAPIDocument(packageToCreate));
}
PackageId id = packageService.CreatePackageOneStep (packageToCreate, package.Documents.Values);
return id;
}
