internal Silanis.ESL.API.Package ToAPIPackage()
{
if (sdkPackage == null)
{
return(apiPackage);
}
Silanis.ESL.API.Package package = new Silanis.ESL.API.Package();
package.Name = sdkPackage.Name;
package.Due = sdkPackage.ExpiryDate;
package.Autocomplete = sdkPackage.Autocomplete;
if (sdkPackage.Description != null)
{
package.Description = sdkPackage.Description;
}
if (sdkPackage.EmailMessage != null)
{
package.EmailMessage = sdkPackage.EmailMessage;
}
if (sdkPackage.Language != null)
{
package.Language = sdkPackage.Language.TwoLetterISOLanguageName;
}
if (sdkPackage.Settings != null)
{
package.Settings = sdkPackage.Settings.toAPIPackageSettings();
}
if (sdkPackage.SenderInfo != null)
{
package.Sender = new SenderConverter(sdkPackage.SenderInfo).ToAPISender();
}
if (sdkPackage.Attributes != null)
{
package.Data = sdkPackage.Attributes.Contents;
}
int signerCount = 1;
foreach (Signer signer in sdkPackage.Signers.Values)
{
Silanis.ESL.API.Role role = new SignerConverter(signer).ToAPIRole("role" + signerCount);
package.AddRole(role);
signerCount++;
}
foreach (Signer signer in sdkPackage.Placeholders.Values)
{
Silanis.ESL.API.Role role = new SignerConverter(signer).ToAPIRole("role" + signerCount);
package.AddRole(role);
signerCount++;
}
return(package);
}
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();
foreach (Silanis.ESL.API.Role role in package.Roles)
{
if (role.Signers.Count == 0)
{
continue;
}
Signer signer = SignerBuilder.NewSignerFromAPISigner(role).Build();
WithSigner(signer);
}
foreach (Silanis.ESL.API.Document apiDocument in package.Documents)
{
Document document = DocumentBuilder.NewDocumentFromAPIDocument(apiDocument, package).Build();
WithDocument(document);
}
}
internal Silanis.ESL.API.Document ToAPIDocument(Silanis.ESL.API.Package createdPackage)
{
Silanis.ESL.API.Document doc = new Silanis.ESL.API.Document();
doc.Name = Name;
doc.Id = Id;
doc.Index = Index;
doc.Extract = Extract;
Converter converter = new Converter();
foreach (Signature signature in signatures)
{
Silanis.ESL.API.Approval approval = converter.ConvertToApproval(signature);
approval.Role = FindRoleIdForSignature(signature.SignerEmail, createdPackage);
doc.AddApproval(approval);
}
foreach (Field field in fields)
{
doc.AddField(converter.ToAPIField(field));
}
return(doc);
}
internal Silanis.ESL.API.Package ToAPIPackage()
{
if (sdkPackage == null)
{
return apiPackage;
}
Silanis.ESL.API.Package package = new Silanis.ESL.API.Package();
package.Name = sdkPackage.Name;
package.Due = sdkPackage.ExpiryDate;
package.Autocomplete = sdkPackage.Autocomplete;
if (sdkPackage.Description != null)
{
package.Description = sdkPackage.Description;
}
if (sdkPackage.EmailMessage != null)
{
package.EmailMessage = sdkPackage.EmailMessage;
}
if (sdkPackage.Language != null)
{
package.Language = sdkPackage.Language.TwoLetterISOLanguageName;
}
if (sdkPackage.Settings != null)
{
package.Settings = sdkPackage.Settings.toAPIPackageSettings();
}
if (sdkPackage.SenderInfo != null)
{
package.Sender = new SenderConverter(sdkPackage.SenderInfo).ToAPISender();
}
if (sdkPackage.Attributes != null)
{
package.Data = sdkPackage.Attributes.Contents;
}
int signerCount = 1;
foreach (Signer signer in sdkPackage.Signers.Values)
{
Silanis.ESL.API.Role role = new SignerConverter(signer).ToAPIRole("role" + signerCount);
package.AddRole(role);
signerCount++;
}
foreach (Signer signer in sdkPackage.Placeholders.Values)
{
Silanis.ESL.API.Role role = new SignerConverter(signer).ToAPIRole("role" + signerCount);
package.AddRole(role);
signerCount++;
}
return package;
}
internal Silanis.ESL.API.Package ToAPIPackage()
{
Silanis.ESL.API.Package package = new Silanis.ESL.API.Package();
package.Name = Name;
package.Description = Description;
package.Autocomplete = Autocomplete;
package.Due = ExpiryDate;
package.EmailMessage = EmailMessage;
if (Language != null)
{
package.Language = Language.TwoLetterISOLanguageName;
}
if (Settings != null)
{
package.Settings = Settings.toAPIPackageSettings();
}
int signerCount = 1;
foreach (Signer signer in Signers.Values)
{
Silanis.ESL.API.Role role = new Silanis.ESL.API.Role();
role.Name = "signer" + signerCount;
role.AddSigner(signer.ToAPISigner());
role.Index = signer.SigningOrder;
role.Reassign = signer.CanChangeSigner;
if (String.IsNullOrEmpty(signer.RoleId))
{
role.Id = "role" + signerCount;
}
else
{
role.Id = signer.RoleId;
}
if (!String.IsNullOrEmpty(signer.Message))
{
Silanis.ESL.API.BaseMessage message = new Silanis.ESL.API.BaseMessage();
message.Content = signer.Message;
role.EmailMessage = message;
}
package.AddRole(role);
signerCount++;
}
return(package);
}
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);
}
private string FindRoleIdForSignature(string signerEmail, Silanis.ESL.API.Package createdPackage)
{
foreach (Silanis.ESL.API.Role role in createdPackage.Roles)
{
if (signerEmail.Equals(role.Signers[0].Email))
{
return(role.Id);
}
}
throw new EslException(String.Format("No Role found for signer email {0}", signerEmail));
}
/// <summary>
/// Updates the package's fields and roles.
/// </summary>
/// <param name="packageId">The package id.</param>
/// <param name="package">The updated package.</param>
internal void UpdatePackage(PackageId packageId, Silanis.ESL.API.Package package)
{
string path = template.UrlFor(UrlTemplate.PACKAGE_ID_PATH)
.Replace("{packageId}", packageId.Id)
.Build();
try {
string json = JsonConvert.SerializeObject(package, settings);
byte[] content = Converter.ToBytes(json);
HttpMethods.PutHttp(apiToken, path, content);
} catch (Exception e) {
throw new EslException("Could not update the package." + " Exception: " + e.Message);
}
}
private string FindRoleIdForGroup(GroupId groupId, Silanis.ESL.API.Package createdPackage)
{
foreach (Silanis.ESL.API.Role role in createdPackage.Roles)
{
if (role.Signers.Count > 0 && role.Signers[0].Group != null)
{
if (groupId.Id.Equals(role.Signers[0].Group.Id))
{
return(role.Id);
}
}
}
throw new EslException(String.Format("No Role found for group with id {0}", groupId.Id));
}
/// <summary>
/// Creates a package based on the settings of the pacakge parameter.
/// </summary>
/// <returns>The package id.</returns>
/// <param name="package">The package to create.</param>
internal PackageId CreatePackage(Silanis.ESL.API.Package package)
{
string path = template.UrlFor(UrlTemplate.PACKAGE_PATH)
.Build();
try {
string json = JsonConvert.SerializeObject(package, settings);
byte[] content = Converter.ToBytes(json);
string response = Converter.ToString(HttpMethods.PostHttp(apiToken, path, content));
return(JsonConvert.DeserializeObject <PackageId> (response));
} catch (Exception e) {
throw new EslException("Could not create a new package." + " Exception: " + e.Message);
}
}
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 string CreatePackageFromTemplate(string templateId, Silanis.ESL.API.Package delta)
{
string path = urls.UrlFor(UrlTemplate.CLONE_PACKAGE_PATH).Replace("{packageId}", templateId)
.Build();
try {
string deltaJson = JsonConvert.SerializeObject(delta, settings);
string response = restClient.Post(path, deltaJson);
Silanis.ESL.API.Package apiResult = JsonConvert.DeserializeObject <Silanis.ESL.API.Package> (response);
return(apiResult.Id);
}
catch (EslServerException e) {
throw new EslServerException("Could not create a package from template." + " Exception: " + e.Message, e.ServerError, e);
}
catch (Exception e) {
throw new EslException("Could not create a package from template." + " Exception: " + e.Message, e);
}
}
internal Silanis.ESL.API.Document ToAPIDocument(Silanis.ESL.API.Package createdPackage)
{
Silanis.ESL.API.Document doc = new Silanis.ESL.API.Document();
doc.Name = Name;
doc.Index = Index;
doc.Extract = Extract;
if (Id != null)
{
doc.Id = Id;
}
if (Description != null)
{
doc.Description = Description;
}
Converter converter = new Converter();
foreach (Signature signature in signatures)
{
Silanis.ESL.API.Approval approval = converter.ConvertToApproval(signature);
if (signature.IsGroupSignature())
{
approval.Role = FindRoleIdForGroup(signature.GroupId, createdPackage);
}
else
{
approval.Role = FindRoleIdForSigner(signature.SignerEmail, createdPackage);
}
doc.AddApproval(approval);
}
foreach (Field field in fields)
{
doc.AddField(converter.ToAPIField(field));
}
return(doc);
}
internal string CreateTemplate(Silanis.ESL.API.Package template)
{
string path = urls.UrlFor(UrlTemplate.PACKAGE_PATH).Build();
try
{
string json = JsonConvert.SerializeObject(template, settings);
string response = restClient.Post(path, json);
Silanis.ESL.API.Package apiPackage = JsonConvert.DeserializeObject <Silanis.ESL.API.Package>(response);
return(apiPackage.Id);
}
catch (EslServerException e)
{
throw new EslServerException("Could not create template." + " Exception: " + e.Message, e.ServerError, e);
}
catch (Exception e)
{
throw new EslException("Could not create template." + " Exception: " + e.Message, e);
}
}
public void Update(Silanis.ESL.API.Package apiTemplate)
{
string path = urls.UrlFor(UrlTemplate.PACKAGE_ID_PATH)
.Replace("{packageId}", apiTemplate.Id)
.Build();
try
{
string json = JsonConvert.SerializeObject(apiTemplate, settings);
restClient.Post(path, json);
}
catch (EslServerException e)
{
throw new EslServerException("Could not update template." + " Exception: " + e.Message, e.ServerError, e);
}
catch (Exception e)
{
throw new EslException("Could not update template." + " Exception: " + e.Message, e);
}
}
internal static DocumentBuilder NewDocumentFromAPIDocument(Silanis.ESL.API.Document apiDocument, Silanis.ESL.API.Package package)
{
DocumentBuilder documentBuilder = DocumentBuilder.NewDocumentNamed(apiDocument.Name)
.WithId(apiDocument.Id)
.AtIndex(apiDocument.Index);
foreach (Silanis.ESL.API.Approval apiApproval in apiDocument.Approvals)
{
Signature signature = SignatureBuilder.NewSignatureFromAPIApproval(apiApproval, package).Build();
documentBuilder.WithSignature(signature);
}
foreach (Silanis.ESL.API.Field apiField in apiDocument.Fields)
{
FieldBuilder fieldBuilder = FieldBuilder.NewFieldFromAPIField(apiField);
documentBuilder.WithInjectedField(fieldBuilder);
}
return(documentBuilder);
}
internal Silanis.ESL.API.Package ToAPIPackage()
{
if (sdkPackage == null)
{
return(apiPackage);
}
Silanis.ESL.API.Package package = new Silanis.ESL.API.Package();
package.Name = sdkPackage.Name;
package.Due = sdkPackage.ExpiryDate;
package.Autocomplete = sdkPackage.Autocomplete;
if (sdkPackage.Id != null)
{
package.Id = sdkPackage.Id.ToString();
}
if (sdkPackage.Status != null)
{
package.Status = sdkPackage.Status;
}
if (sdkPackage.Description != null)
{
package.Description = sdkPackage.Description;
}
if (sdkPackage.EmailMessage != null)
{
package.EmailMessage = sdkPackage.EmailMessage;
}
if (sdkPackage.Language != null)
{
if (sdkPackage.Language.IsNeutralCulture)
{
package.Language = sdkPackage.Language.TwoLetterISOLanguageName;
}
else
{
string LanguageCountry = (new RegionInfo(sdkPackage.Language.LCID)).TwoLetterISORegionName;
package.Language = sdkPackage.Language.TwoLetterISOLanguageName + "-" + LanguageCountry;
}
}
if (sdkPackage.Settings != null)
{
package.Settings = sdkPackage.Settings.toAPIPackageSettings();
}
if (sdkPackage.SenderInfo != null)
{
package.Sender = new SenderConverter(sdkPackage.SenderInfo).ToAPISender();
}
if (sdkPackage.Attributes != null)
{
package.Data = sdkPackage.Attributes.Contents;
}
if (sdkPackage.Notarized != null)
{
package.Notarized = sdkPackage.Notarized;
}
if (sdkPackage.Trashed != null)
{
package.Trashed = sdkPackage.Trashed;
}
if (sdkPackage.Visibility != null)
{
package.Visibility = sdkPackage.Visibility;
}
int signerCount = 1;
foreach (Signer signer in sdkPackage.Signers)
{
Silanis.ESL.API.Role role = new SignerConverter(signer).ToAPIRole("signer" + signerCount);
package.AddRole(role);
signerCount++;
}
foreach (Signer signer in sdkPackage.Placeholders)
{
Silanis.ESL.API.Role role = new SignerConverter(signer).ToAPIRole(signer.Id, signer.PlaceholderName);
role.Index = signer.SigningOrder;
package.AddRole(role);
signerCount++;
}
return(package);
}
public SignatureConverter(Silanis.ESL.API.Approval apiApproval, Silanis.ESL.API.Package package)
{
this.apiApproval = apiApproval;
this.package = package;
}
public DocumentPackage GetPackage(PackageId id)
{
Silanis.ESL.API.Package package = packageService.GetPackage(id);
return(new PackageBuilder(package).Build());
}
public SignatureConverter(Silanis.ESL.API.Approval apiApproval, Silanis.ESL.API.Package package)
{
this.apiApproval = apiApproval;
this.package = package;
}
internal Silanis.ESL.API.Package ToAPIPackage()
{
Silanis.ESL.API.Package package = new Silanis.ESL.API.Package();
package.Name = Name;
package.Description = Description;
package.Autocomplete = Autocomplete;
package.Due = ExpiryDate;
package.EmailMessage = EmailMessage;
if (Language != null)
{
package.Language = Language.TwoLetterISOLanguageName;
}
if (Settings != null)
{
package.Settings = Settings.toAPIPackageSettings();
}
if (SenderInfo != null)
{
package.Sender = new SenderConverter(SenderInfo).ToAPISender();
}
if ( Attributes != null ) {
package.Data = Attributes.Contents;
}
int signerCount = 1;
foreach (Signer signer in Signers.Values)
{
Silanis.ESL.API.Role role = new Silanis.ESL.API.Role();
role.Name = "signer" + signerCount;
role.AddSigner(signer.ToAPISigner());
role.Index = signer.SigningOrder;
role.Reassign = signer.CanChangeSigner;
if (String.IsNullOrEmpty(signer.RoleId))
{
role.Id = "role" + signerCount;
}
else
{
role.Id = signer.RoleId;
}
if (!String.IsNullOrEmpty(signer.Message))
{
Silanis.ESL.API.BaseMessage message = new Silanis.ESL.API.BaseMessage();
message.Content = signer.Message;
role.EmailMessage = message;
}
package.AddRole(role);
signerCount++;
}
return package;
}
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);
}
/// <summary>
/// Construct with API object involved in conversion.
/// </summary>
/// <param name="apiPackage">API Package.</param>
public DocumentPackageConverter(Silanis.ESL.API.Package apiPackage)
{
this.apiPackage = apiPackage;
}
/// <summary>
/// Construct with API object involved in conversion.
/// </summary>
/// <param name="apiPackage">API Package.</param>
public DocumentPackageConverter(Silanis.ESL.API.Package apiPackage)
{
this.apiPackage = apiPackage;
}
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));
}
