internal static SignerBuilder NewSignerFromAPISigner(Silanis.ESL.API.Role role)
{
Silanis.ESL.API.Signer eslSigner = role.Signers [0];
SignerBuilder builder = SignerBuilder.NewSignerWithEmail(eslSigner.Email)
.WithCustomId(eslSigner.Id)
.WithFirstName(eslSigner.FirstName)
.WithLastName(eslSigner.LastName)
.WithCompany(eslSigner.Company)
.WithTitle(eslSigner.Title)
.SigningOrder(role.Index);
if (role.Reassign)
{
builder.CanChangeSigner();
}
if (role.EmailMessage != null)
{
builder.WithEmailMessage(role.EmailMessage.Content);
}
if (role.Locked)
{
builder.Lock();
}
if (eslSigner.Delivery != null && eslSigner.Delivery.Email)
{
builder.DeliverSignedDocumentsByEmail();
}
return(builder);
}
public void ConvertAPIToSDK()
{
apiRole = CreateTypicalAPIRole();
apiSigner1 = apiRole.Signers[0];
sdkSigner1 = new SignerConverter(apiRole).ToSDKSigner();
Assert.IsNotNull(sdkSigner1);
Assert.AreEqual(apiSigner1.Email, sdkSigner1.Email);
Assert.AreEqual(apiSigner1.FirstName, sdkSigner1.FirstName);
Assert.AreEqual(apiSigner1.LastName, sdkSigner1.LastName);
Assert.AreEqual(apiSigner1.Company, sdkSigner1.Company);
Assert.AreEqual(apiSigner1.Title, sdkSigner1.Title);
Assert.AreEqual(apiRole.Id, sdkSigner1.Id);
Assert.AreEqual(apiRole.Index, sdkSigner1.SigningOrder);
Assert.AreEqual(apiRole.Reassign, sdkSigner1.CanChangeSigner);
Assert.AreEqual(apiRole.EmailMessage.Content, sdkSigner1.Message);
Assert.AreEqual(apiSigner1.Delivery.Email, sdkSigner1.DeliverSignedDocumentsByEmail);
string attachmentName = apiRole.AttachmentRequirements[0].Name;
Silanis.ESL.API.AttachmentRequirement apiAttachment = apiRole.AttachmentRequirements[0];
Silanis.ESL.SDK.AttachmentRequirement sdkAttachment = sdkSigner1.GetAttachmentRequirement(attachmentName);
Assert.AreEqual(attachmentName, sdkSigner1.GetAttachmentRequirement(attachmentName).Name);
Assert.AreEqual(apiAttachment.Description, sdkAttachment.Description);
Assert.AreEqual(apiAttachment.Required, sdkAttachment.Required);
Assert.AreEqual(apiAttachment.Status.ToString(), sdkAttachment.Status.ToString());
Assert.AreEqual(apiAttachment.Comment, sdkAttachment.SenderComment);
}
private Silanis.ESL.SDK.Signer NewRegularSignerFromAPIRole()
{
Silanis.ESL.API.Signer eslSigner = apiRole.Signers[0];
SignerBuilder builder = SignerBuilder.NewSignerWithEmail(eslSigner.Email)
.WithCustomId(eslSigner.Id)
.WithFirstName(eslSigner.FirstName)
.WithLastName(eslSigner.LastName)
.WithCompany(eslSigner.Company)
.WithLanguage(eslSigner.Language)
.WithTitle(eslSigner.Title)
.ChallengedWithKnowledgeBasedAuthentication(new KnowledgeBasedAuthenticationConverter(eslSigner.KnowledgeBasedAuthentication).ToSDKKnowledgeBasedAuthentication());
if (apiRole.Index.HasValue)
{
builder.SigningOrder(apiRole.Index.Value);
}
foreach (Silanis.ESL.API.AttachmentRequirement attachmentRequirement in apiRole.AttachmentRequirements)
{
builder.WithAttachmentRequirement(new AttachmentRequirementConverter(attachmentRequirement).ToSDKAttachmentRequirement());
}
if (apiRole.Id != null)
{
builder.WithCustomId(apiRole.Id);
}
if (apiRole.Reassign.Value)
{
builder.CanChangeSigner();
}
if (apiRole.EmailMessage != null)
{
builder.WithEmailMessage(apiRole.EmailMessage.Content);
}
if (eslSigner.Delivery != null && eslSigner.Delivery.Email.Value)
{
builder.DeliverSignedDocumentsByEmail();
}
builder.WithAuthentication(new AuthenticationConverter(eslSigner.Auth).ToSDKAuthentication());
Signer signer = builder.Build();
if (apiSigner.SignerType != null)
{
signer.SignerType = apiSigner.SignerType;
}
if (apiRole.Locked.Value)
{
signer.Locked = true;
}
return(signer);
}
public void ConvertAPIToAPI()
{
apiRole = CreateTypicalAPIRole();
apiSigner1 = new SignerConverter(apiRole).ToAPISigner();
Assert.IsNotNull(apiSigner1);
Assert.AreEqual(apiSigner1, apiRole.Signers[0]);
}
public void ConvertAPIToAPI()
{
apiRole = CreateTypicalAPIRole();
apiSigner1 = new SignerConverter(apiRole).ToAPISigner();
Assert.IsNotNull(apiSigner1);
Assert.AreEqual(apiSigner1, apiRole.Signers[0]);
}
public SignerConverter (Silanis.ESL.API.Role apiRole)
{
this.apiRole = apiRole;
if (apiRole != null)
{
this.apiSigner = apiRole.Signers[0];
}
}
public SignerConverter(Silanis.ESL.API.Role apiRole)
{
this.apiRole = apiRole;
if (apiRole != null)
{
this.apiSigner = apiRole.Signers[0];
}
}
public void ConvertSDKToAPI()
{
sdkSigner1 = CreateTypicalSDKSigner();
apiSigner1 = new SignerConverter(sdkSigner1).ToAPISigner();
Assert.IsNotNull(apiSigner1);
Assert.AreEqual(apiSigner1.Email, sdkSigner1.Email);
Assert.AreEqual(apiSigner1.FirstName, sdkSigner1.FirstName);
Assert.AreEqual(apiSigner1.LastName, sdkSigner1.LastName);
Assert.AreEqual(apiSigner1.Company, sdkSigner1.Company);
Assert.AreEqual(apiSigner1.Title, sdkSigner1.Title);
}
public void ConvertSDKToAPI()
{
sdkSigner1 = CreateTypicalSDKSigner();
apiSigner1 = new SignerConverter(sdkSigner1).ToAPISigner();
Assert.IsNotNull(apiSigner1);
Assert.AreEqual(apiSigner1.Email, sdkSigner1.Email);
Assert.AreEqual(apiSigner1.FirstName, sdkSigner1.FirstName);
Assert.AreEqual(apiSigner1.LastName, sdkSigner1.LastName);
Assert.AreEqual(apiSigner1.Company, sdkSigner1.Company);
Assert.AreEqual(apiSigner1.Title, sdkSigner1.Title);
}
internal static SignatureBuilder NewSignatureFromAPIApproval(Silanis.ESL.API.Approval apiApproval, Silanis.ESL.API.Package package)
{
Silanis.ESL.API.Signer apiSigner = null;
foreach (Silanis.ESL.API.Role role in package.Roles)
{
if (role.Id.Equals(apiApproval.Role))
{
apiSigner = role.Signers [0];
}
}
if (apiSigner == null)
{
return(null);
}
SignatureBuilder signatureBuilder = new SignatureBuilder(apiSigner.Email).WithName(apiApproval.Name);
Silanis.ESL.API.Field apiSignatureField = null;
foreach (Silanis.ESL.API.Field apiField in apiApproval.Fields)
{
if (apiField.Type == Silanis.ESL.API.FieldType.SIGNATURE)
{
apiSignatureField = apiField;
}
else
{
FieldBuilder fieldBuilder = FieldBuilder.NewFieldFromAPIField(apiField);
signatureBuilder.WithField(fieldBuilder);
}
}
if (apiSignatureField == null)
{
signatureBuilder.WithStyle(SignatureStyle.ACCEPTANCE);
signatureBuilder.WithSize(0, 0);
}
else
{
signatureBuilder.WithStyle(FromAPIFieldSubType(apiSignatureField.Subtype))
.OnPage(apiSignatureField.Page)
.AtPosition(apiSignatureField.Left, apiSignatureField.Top)
.WithSize(apiSignatureField.Width, apiSignatureField.Height);
if (apiSignatureField.Extract)
{
signatureBuilder.EnableExtraction();
}
}
return(signatureBuilder);
}
internal Silanis.ESL.API.Signer ToAPISigner()
{
if (sdkSigner == null)
{
return(apiSigner);
}
if (sdkSigner.IsPlaceholderSigner())
{
return(null);
}
Silanis.ESL.API.Signer signer = new Silanis.ESL.API.Signer();
if (!sdkSigner.IsGroupSigner())
{
signer.Email = sdkSigner.Email;
signer.FirstName = sdkSigner.FirstName;
signer.LastName = sdkSigner.LastName;
signer.Title = sdkSigner.Title;
signer.Company = sdkSigner.Company;
if (sdkSigner.DeliverSignedDocumentsByEmail)
{
signer.Delivery = new Silanis.ESL.API.Delivery();
signer.Delivery.Email = sdkSigner.DeliverSignedDocumentsByEmail;
}
signer.KnowledgeBasedAuthentication = new KnowledgeBasedAuthenticationConverter(sdkSigner.KnowledgeBasedAuthentication).ToAPIKnowledgeBasedAuthentication();
}
else
{
signer.Group = new Silanis.ESL.API.Group();
signer.Group.Id = sdkSigner.GroupId.Id;
}
if (!String.IsNullOrEmpty(sdkSigner.Language))
{
signer.Language = sdkSigner.Language;
}
if (!String.IsNullOrEmpty(sdkSigner.Id))
{
signer.Id = sdkSigner.Id;
}
signer.Auth = new AuthenticationConverter(sdkSigner.Authentication).ToAPIAuthentication();
return(signer);
}
internal PackageBuilder(Silanis.ESL.API.Package package)
{
this.id = new PackageId(package.Id);
this.packageName = package.Name;
this.autocomplete = package.Autocomplete;
this.description = package.Description;
this.expiryDate = package.Due;
this.status = ConvertPackageStatus(package.Status);
this.emailMessage = package.EmailMessage;
this.settings = new DocumentPackageSettingsBuilder(package.Settings).build();
this.senderInfo = new SenderConverter(package.Sender).ToSDKSenderInfo();
this.attributes = new DocumentPackageAttributes(package.Data);
foreach (Silanis.ESL.API.Role role in package.Roles)
{
if (role.Signers.Count == 0)
{
continue;
}
if (role.Signers[0].Group != null)
{
WithSigner(SignerBuilder.NewSignerFromGroup(new GroupId(role.Signers[0].Group.Id)));
}
else
{
WithSigner(SignerBuilder.NewSignerFromAPISigner(role).Build());
if (role.Type == Silanis.ESL.API.RoleType.SENDER)
{
Silanis.ESL.API.Signer senderSigner = role.Signers[0];
WithSenderInfo(SenderInfoBuilder.NewSenderInfo(senderSigner.Email)
.WithName(senderSigner.FirstName, senderSigner.LastName)
.WithCompany(senderSigner.Company)
.WithTitle(senderSigner.Title));
}
}
}
foreach (Silanis.ESL.API.Document apiDocument in package.Documents)
{
Document document = DocumentBuilder.NewDocumentFromAPIDocument(apiDocument, package).Build();
WithDocument(document);
}
}
internal Silanis.ESL.API.Signer ToAPISigner()
{
Silanis.ESL.API.Signer signer = new Silanis.ESL.API.Signer();
signer.Email = Email;
signer.FirstName = FirstName;
signer.LastName = LastName;
signer.Title = Title;
signer.Company = Company;
signer.Auth = authentication.ToAPIAuthentication();
if (!String.IsNullOrEmpty(Id))
{
signer.Id = Id;
}
return(signer);
}
internal Silanis.ESL.API.Signer ToAPISigner()
{
if (sdkSigner == null)
{
return apiSigner;
}
if (sdkSigner.IsPlaceholderSigner())
{
return null;
}
Silanis.ESL.API.Signer signer = new Silanis.ESL.API.Signer ();
if (!sdkSigner.IsGroupSigner())
{
signer.Email = sdkSigner.Email;
signer.FirstName = sdkSigner.FirstName;
signer.LastName = sdkSigner.LastName;
signer.Title = sdkSigner.Title;
signer.Company = sdkSigner.Company;
if (sdkSigner.DeliverSignedDocumentsByEmail)
{
signer.Delivery = new Silanis.ESL.API.Delivery();
signer.Delivery.Email = sdkSigner.DeliverSignedDocumentsByEmail;
}
}
else
{
signer.Group = new Silanis.ESL.API.Group();
signer.Group.Id = sdkSigner.GroupId.Id;
}
if (!String.IsNullOrEmpty(sdkSigner.Id))
{
signer.Id = sdkSigner.Id;
}
signer.Auth = new AuthenticationConverter(sdkSigner.Authentication).ToAPIAuthentication();
return signer;
}
private Silanis.ESL.API.Role CreateTypicalAPIRole()
{
Silanis.ESL.API.Role apiRole = new Silanis.ESL.API.Role();
Silanis.ESL.API.Signer apiSigner = new Silanis.ESL.API.Signer();
apiSigner.Email = "*****@*****.**";
apiSigner.FirstName = "Signer first name";
apiSigner.LastName = "Signer last name";
apiSigner.Company = "ABC Inc.";
apiSigner.SignerType = "THIRD_PARTY_SIGNER";
apiSigner.Language = "fr";
apiSigner.Title = "Doctor";
Silanis.ESL.API.Delivery delivery = new Silanis.ESL.API.Delivery();
delivery.Download = true;
delivery.Email = true;
apiSigner.Delivery = delivery;
apiSigner.Id = "1";
apiRole.AddSigner(apiSigner);
apiRole.Id = "3";
apiRole.Name = "Signer name";
apiRole.Index = 0;
apiRole.Reassign = true;
Silanis.ESL.API.BaseMessage baseMessage = new Silanis.ESL.API.BaseMessage();
baseMessage.Content = "Base message content.";
apiRole.EmailMessage = baseMessage;
apiRole.Locked = true;
Silanis.ESL.API.AttachmentRequirement attachmentRequirement = new Silanis.ESL.API.AttachmentRequirement();
attachmentRequirement.Name = "Driver's license";
attachmentRequirement.Description = "Please upload your scanned driver's license.";
attachmentRequirement.Status = Silanis.ESL.SDK.RequirementStatus.INCOMPLETE.getApiValue();
attachmentRequirement.Required = true;
attachmentRequirement.Comment = "Attachment was not uploaded";
apiRole.AddAttachmentRequirement(attachmentRequirement);
return(apiRole);
}
public void ConvertAPIToSDK()
{
apiRole = CreateTypicalAPIRole();
apiSigner1 = apiRole.Signers[0];
sdkSigner1 = new SignerConverter(apiRole).ToSDKSigner();
Assert.IsNotNull(sdkSigner1);
Assert.AreEqual(apiSigner1.Email, sdkSigner1.Email);
Assert.AreEqual(apiSigner1.FirstName, sdkSigner1.FirstName);
Assert.AreEqual(apiSigner1.LastName, sdkSigner1.LastName);
Assert.AreEqual(apiSigner1.Company, sdkSigner1.Company);
Assert.AreEqual(apiSigner1.Title, sdkSigner1.Title);
Assert.AreEqual(apiRole.Id, sdkSigner1.Id);
Assert.AreEqual(apiRole.Index, sdkSigner1.SigningOrder);
Assert.AreEqual(apiRole.Reassign, sdkSigner1.CanChangeSigner);
Assert.AreEqual(apiRole.EmailMessage.Content, sdkSigner1.Message);
Assert.AreEqual(apiSigner1.Delivery.Email, sdkSigner1.DeliverSignedDocumentsByEmail);
string attachmentName = apiRole.AttachmentRequirements[0].Name;
Silanis.ESL.API.AttachmentRequirement apiAttachment = apiRole.AttachmentRequirements[0];
Silanis.ESL.SDK.AttachmentRequirement sdkAttachment = sdkSigner1.Attachments[attachmentName];
Assert.AreEqual(attachmentName, sdkSigner1.Attachments[attachmentName].Name);
Assert.AreEqual(apiAttachment.Description, sdkAttachment.Description);
Assert.AreEqual(apiAttachment.Required, sdkAttachment.Required);
Assert.AreEqual(apiAttachment.Status.ToString(), sdkAttachment.Status.ToString());
Assert.AreEqual(apiAttachment.Comment, sdkAttachment.SenderComment);
}
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);
}
private Silanis.ESL.API.Role CreateTypicalAPIRole()
{
Silanis.ESL.API.Role apiRole = new Silanis.ESL.API.Role();
Silanis.ESL.API.Signer apiSigner = new Silanis.ESL.API.Signer();
apiSigner.Email = "*****@*****.**";
apiSigner.FirstName = "Signer first name";
apiSigner.LastName = "Signer last name";
apiSigner.Company = "ABC Inc.";
apiSigner.Title = "Doctor";
Silanis.ESL.API.Delivery delivery = new Silanis.ESL.API.Delivery();
delivery.Download = true;
delivery.Email = true;
apiSigner.Delivery = delivery;
apiSigner.Id = "1";
apiRole.AddSigner(apiSigner);
apiRole.Id = "3";
apiRole.Name = "Signer name";
apiRole.Index = 0;
apiRole.Reassign = true;
Silanis.ESL.API.BaseMessage baseMessage = new Silanis.ESL.API.BaseMessage();
baseMessage.Content = "Base message content.";
apiRole.EmailMessage = baseMessage;
apiRole.Locked = true;
Silanis.ESL.API.AttachmentRequirement attachmentRequirement = new Silanis.ESL.API.AttachmentRequirement();
attachmentRequirement.Name = "Driver's license";
attachmentRequirement.Description = "Please upload your scanned driver's license.";
attachmentRequirement.Status = Silanis.ESL.API.RequirementStatus.INCOMPLETE;
attachmentRequirement.Required = true;
attachmentRequirement.Comment = "Attachment was not uploaded";
apiRole.AddAttachmentRequirement(attachmentRequirement);
return apiRole;
}
