/// <summary>
/// Initializes a new instance of CommandExecuter
/// </summary>
/// <param name="commandName">The name of the command that the CommandExecuter will execute</param>
/// <param name="commandManager">The CommandManager object that will handle the command executed by this CommandExecuter instance</param>
public CommandExecuter(string commandName, CommandManager commandManager)
{
this.commandName = commandName;
this.responseRequired = true;
SignatureBuilder sb = new SignatureBuilder();
sb.AddNewFromDelegate(new StringArrayEventHandler(this.DefaultParameterParser));
this.signature = sb.GenerateSignature(this.commandName);
//if (commandManager != null)
// commandManager.CommandExecuters.Add(this);
}
override public void Execute()
{
String signerId = "myCustomSignerId";
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("SessionCreationExample: " + DateTime.Now)
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith")
.WithCustomId(signerId))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(100, 100)))
.Build();
PackageId packageId = eslClient.CreatePackage(superDuperPackage);
eslClient.SendPackage(packageId);
signerSessionToken = eslClient.CreateSignerSessionToken(packageId, email1);
}
/// <summary>
/// Creates the object finder Signatures
/// </summary>
private void CreateKinectTrackerSignatures()
{
SignatureBuilder sb = new SignatureBuilder();
sb.AddNewFromTypes(typeof(string));
sgnFindObject = sb.GenerateSignature("kt_find");
sgnTrainObject = sb.GenerateSignature("kt_train");
sb.Clear();
// Calibra una persona y devuelve el Id de la persona calibrada
sb.AddNewFromTypes(typeof(int));
//sb.AddNewFromTypes();
sgnCalibrate = sb.GenerateSignature("kt_calibrate");
sb.Clear();
// Locate
// Skeleton Devuelve las coordenadas x, y, z del centro del esqueleto
// Cammera Devuelve la ubicacion del centroide de la camisa de la persona detectada 2 double (ang in rad)
sb.AddNewFromTypes(typeof(double), typeof(double));
sb.AddNewFromTypes(typeof(double), typeof(double), typeof(double));
sgnLocate = sb.GenerateSignature("kt_calibrate");
}
override public void Execute()
{
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("FieldInjectionExample " + DateTime.Now)
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith"))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(100, 100))
.WithInjectedField(FieldBuilder.TextField()
.WithId("AGENT_SIG_1")
.WithName("AGENT_SIG_1")
.WithValue("Test Value")))
.Build();
PackageId packageId = eslClient.CreatePackage(superDuperPackage);
eslClient.SendPackage(packageId);
}
private void Initialize(IOptions <S3Config> options, INetworkDriver networkDriver, ILoggerFactory loggerFactory)
{
Assembly assembly = typeof(S3Config).Assembly;
SimpleServiceProvider provider = new SimpleServiceProvider((typeof(IOptions <S3Config>), options));
IEnumerable <IValidator> validators = CreateInstances <IValidator>(assembly, provider);
IEnumerable <IRequestMarshal> requestMarshals = CreateInstances <IRequestMarshal>(assembly, provider);
IEnumerable <IResponseMarshal> responseMarshals = CreateInstances <IResponseMarshal>(assembly, provider);
IEnumerable <IPostMapper> postMappers = CreateInstances <IPostMapper>(assembly, provider);
IEnumerable <IRequestWrapper> requestWrappers = CreateInstances <IRequestWrapper>(assembly, provider).ToList();
IEnumerable <IResponseWrapper> responseWrappers = CreateInstances <IResponseWrapper>(assembly, provider).ToList();
ValidatorFactory validatorFactory = new ValidatorFactory(validators);
IMarshalFactory marshalFactory = new MarshalFactory(requestMarshals, responseMarshals);
IPostMapperFactory postMapperFactory = new PostMapperFactory(postMappers);
IScopeBuilder scopeBuilder = new ScopeBuilder(options);
ISigningKeyBuilder signingKeyBuilder = new SigningKeyBuilder(options, loggerFactory.CreateLogger <SigningKeyBuilder>());
ISignatureBuilder signatureBuilder = new SignatureBuilder(signingKeyBuilder, scopeBuilder, loggerFactory.CreateLogger <SignatureBuilder>(), options);
HeaderAuthorizationBuilder authorizationBuilder = new HeaderAuthorizationBuilder(options, scopeBuilder, signatureBuilder, loggerFactory.CreateLogger <HeaderAuthorizationBuilder>());
ChunkedSignatureBuilder chunkedBuilder = new ChunkedSignatureBuilder(signingKeyBuilder, scopeBuilder, loggerFactory.CreateLogger <ChunkedSignatureBuilder>());
ChunkedContentRequestStreamWrapper chunkedStreamWrapper = new ChunkedContentRequestStreamWrapper(options, chunkedBuilder, signatureBuilder);
DefaultRequestHandler requestHandler = new DefaultRequestHandler(options, validatorFactory, marshalFactory, postMapperFactory, networkDriver, authorizationBuilder, loggerFactory.CreateLogger <DefaultRequestHandler>(), new[] { chunkedStreamWrapper });
ObjectOperations objectOperations = new ObjectOperations(requestHandler, requestWrappers, responseWrappers);
_objectClient = new S3ObjectClient(objectOperations);
BucketOperations bucketOperations = new BucketOperations(requestHandler);
_bucketClient = new S3BucketClient(bucketOperations);
MultipartOperations multipartOperations = new MultipartOperations(requestHandler, requestWrappers, responseWrappers);
_multipartClient = new S3MultipartClient(multipartOperations, objectOperations);
Transfer = new Transfer(objectOperations, multipartOperations);
}
override public void Execute()
{
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed(PackageName)
.WithSettings(DocumentPackageSettingsBuilder.NewDocumentPackageSettings()
.WithInPerson()
.WithoutLanguageDropDown()
.DisableFirstAffidavit()
.DisableSecondAffidavit()
.HideOwnerInPersonDropDown()
.WithDecline()
.WithOptOut()
.WithEnforceCaptureSignature()
.WithDeclineReason(DECLINE_REASON_1)
.WithDeclineReason(DECLINE_REASON_2)
.WithDeclineReason(DECLINE_REASON_3)
.WithoutDeclineOther()
.WithOptOutReason(OPT_OUT_REASON_1)
.WithOptOutReason(OPT_OUT_REASON_2)
.WithOptOutReason(OPT_OUT_REASON_3)
.WithoutOptOutOther()
.WithHandOverLinkHref("http://www.google.ca")
.WithHandOverLinkText("click here")
.WithHandOverLinkTooltip("link tooltip")
.WithCeremonyLayoutSettings(CeremonyLayoutSettingsBuilder.NewCeremonyLayoutSettings()
.WithoutGlobalConfirmButton()
.WithoutGlobalDownloadButton()
.WithoutGlobalSaveAsLayoutButton()))
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith"))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(100, 100)))
.Build();
packageId = eslClient.CreateAndSendPackage(superDuperPackage);
retrievedPackage = eslClient.GetPackage(packageId);
}
public static void Main(string[] args)
{
// Create new esl client with api token and base url
EslClient client = new EslClient(apiToken, baseUrl);
FileInfo file = new FileInfo(Directory.GetCurrentDirectory() + "/src/document.pdf");
DocumentPackage package = PackageBuilder.NewPackageNamed("Signing Order " + DateTime.Now)
.DescribedAs("This is a signer workflow example")
.WithSigner(SignerBuilder.NewSignerWithEmail("*****@*****.**")
.WithFirstName("John")
.WithLastName("Smith")
.SigningOrder(1))
.WithSigner(SignerBuilder.NewSignerWithEmail("*****@*****.**")
.WithFirstName("Coco")
.WithLastName("Beware")
.SigningOrder(2))
.WithDocument(DocumentBuilder.NewDocumentNamed("Second Document")
.FromFile(file.FullName)
.WithSignature(SignatureBuilder.SignatureFor("*****@*****.**")
.OnPage(0)
.AtPosition(500, 100))
.WithSignature(SignatureBuilder.InitialsFor("*****@*****.**")
.OnPage(0)
.AtPosition(500, 200))
.WithSignature(SignatureBuilder.CaptureFor("*****@*****.**")
.OnPage(0)
.AtPosition(500, 300)))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromFile(file.FullName)
.WithSignature(SignatureBuilder.SignatureFor("*****@*****.**")
.OnPage(0)
.AtPosition(500, 100)))
.Build();
PackageId id = client.CreatePackage(package);
client.SendPackage(id);
Console.WriteLine("Package {0} was sent", id.Id);
}
override public void Execute()
{
string documentId = "myDocumentId";
DocumentPackage package = PackageBuilder.NewPackageNamed("DocumentRetrievalExample " + DateTime.Now)
.DescribedAs("This is a new package")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith"))
.WithDocument(DocumentBuilder.NewDocumentNamed("My Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithId(documentId)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(100, 100)))
.Build();
PackageId packageId = eslClient.CreatePackage(package);
eslClient.SendPackage(packageId);
downloadDocumentById(packageId, documentId);
}
override public void Execute()
{
senderEmail = System.Guid.NewGuid().ToString().Replace("-", "") + "@e-signlive.com";
ossClient.AccountService.InviteUser(
AccountMemberBuilder.NewAccountMember(senderEmail)
.WithFirstName("firstName")
.WithLastName("lastName")
.WithCompany("company")
.WithTitle("title")
.WithLanguage("language")
.WithPhoneNumber("phoneNumber")
.Build()
);
DocumentPackage template =
PackageBuilder.NewPackageNamed("CustomSenderInfoInCreateNewTemplateExample: " + DateTime.Now)
.DescribedAs("This is a template created using the eSignLive SDK")
.WithEmailMessage("This message should be delivered to all signers")
.WithSigner(SignerBuilder.NewSignerPlaceholder(new Placeholder("PlaceholderId1")))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(new Placeholder("PlaceholderId1"))
.OnPage(0)
.AtPosition(100, 100)
)
)
.Build();
templateId = ossClient.CreateTemplate(template);
packageId = ossClient.CreatePackageFromTemplate(templateId,
PackageBuilder.NewPackageNamed(PackageName)
.WithSenderInfo(SenderInfoBuilder.NewSenderInfo(senderEmail)
.WithName(SENDER_FIRST_NAME, SENDER_SECOND_NAME)
.WithTitle(SENDER_TITLE)
.WithCompany(SENDER_COMPANY))
.Build());
retrievedPackage = ossClient.GetPackage(packageId);
}
override public void Execute()
{
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("Policy " + DateTime.Now)
.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")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithCustomId("Client1")
.WithFirstName("John")
.WithLastName("Smith")
.WithTitle("Managing Director")
.WithCompany("Acme Inc."))
.WithSigner(SignerBuilder.NewSignerWithEmail(email2)
.WithFirstName("Patty")
.WithLastName("Galant"))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.WithField(FieldBuilder.CheckBox()
.OnPage(0)
.AtPosition(400, 200)
.WithValue("x"))
.AtPosition(100, 100)))
.WithDocument(DocumentBuilder.NewDocumentNamed("Second Document")
.FromStream(fileStream2, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email2)
.OnPage(0)
.AtPosition(100, 200)
)
)
.Build();
PackageId packageId = eslClient.CreatePackage(superDuperPackage);
eslClient.SendPackage(packageId);
SessionToken sessionToken = eslClient.CreateSessionToken(packageId, "Client1");
}
override public void Execute()
{
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("SignatureStylesExample: " + DateTime.Now)
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith"))
.WithDocument(DocumentBuilder.NewDocumentNamed(DOCUMENT_NAME)
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(FULL_NAME_SIGNATURE_PAGE)
.AtPosition(FULL_NAME_SIGNATURE_POSITION_X, FULL_NAME_SIGNATURE_POSITION_Y))
.WithSignature(SignatureBuilder.InitialsFor(email1)
.OnPage(INITIAL_SIGNATURE_PAGE)
.AtPosition(INITIAL_SIGNATURE_POSITION_X, INITIAL_SIGNATURE_POSITION_Y))
.WithSignature(SignatureBuilder.CaptureFor(email1)
.OnPage(HAND_DRAWN_SIGNATURE_PAGE)
.AtPosition(HAND_DRAWN_SIGNATURE_POSITION_X, HAND_DRAWN_SIGNATURE_POSITION_Y)))
.Build();
packageId = eslClient.CreatePackage(superDuperPackage);
eslClient.SendPackage(packageId);
}
override public void Execute()
{
DocumentPackage package = PackageBuilder.NewPackageNamed("C# GetSigningStatusExample " + DateTime.Now)
.DescribedAs("This is a new package")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith"))
.WithDocument(DocumentBuilder.NewDocumentNamed("My Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(500, 100)))
.Build();
PackageId id = eslClient.CreatePackage(package);
SigningStatus status = eslClient.GetSigningStatus(id, null, null);
eslClient.SendPackage(id);
status = eslClient.GetSigningStatus(id, null, null);
}
override public void Execute()
{
DocumentPackage package = PackageBuilder.NewPackageNamed(PackageName)
.DescribedAs("This is a new package")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith"))
.WithDocument(DocumentBuilder.NewDocumentNamed("My Document")
.FromStream(fileStream1, DocumentType.PDF)
.EnableExtraction()
.WithSignature(SignatureBuilder.SignatureFor(email1)
.WithName("AGENT_SIG_1")
.WithPositionExtracted()
.WithField(FieldBuilder.SignatureDate()
.WithName("AGENT_SIG_2")
.WithPositionExtracted())))
.Build();
PackageId id = eslClient.CreatePackage(package);
eslClient.SendPackage(id);
}
override public void Execute()
{
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("MixingSignatureAndAcceptanceOnOnedocumentExample: " + DateTime.Now)
.WithSettings(DocumentPackageSettingsBuilder.NewDocumentPackageSettings().WithInPerson())
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John1")
.WithLastName("Smith1"))
.WithSigner(SignerBuilder.NewSignerWithEmail(email2)
.WithFirstName("John2")
.WithLastName("Smith2"))
.WithDocument(DocumentBuilder.NewDocumentNamed(DOCUMENT_NAME)
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(100, 100))
.WithSignature(SignatureBuilder.AcceptanceFor(email2)))
.Build();
packageId = eslClient.CreatePackage(superDuperPackage);
eslClient.SendPackage(packageId);
retrievedPackage = eslClient.GetPackage(packageId);
}
override public void Execute()
{
this.fileStream1 = File.OpenRead(new FileInfo(Directory.GetCurrentDirectory() + "/SampleDocuments/document-with-fields.pdf").FullName);
DocumentPackage package = PackageBuilder.NewPackageNamed(PackageName)
.DescribedAs("This is a new package")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith"))
.WithDocument(DocumentBuilder.NewDocumentNamed("My Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.WithName("AGENT_SIG_1"))
.WithInjectedField(FieldBuilder.Label()
.WithName("AGENT_SIG_2")
.WithValue("Céline Lelièvre")))
.Build();
PackageId id = eslClient.CreatePackage(package);
eslClient.SendPackage(id);
}
override public void Execute()
{
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("SignerQnAChallengeExample: " + DateTime.Now)
.DescribedAs("This is a Q&A authentication example")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith")
.ChallengedWithQuestions(ChallengeBuilder.FirstQuestion(FIRST_QUESTION)
.Answer(FIRST_ANSWER)
.SecondQuestion(SECOND_QUESTION)
.Answer(SECOND_ANSWER)))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(199, 100)))
.Build();
packageId = eslClient.CreatePackage(superDuperPackage);
eslClient.SendPackage(packageId);
}
public static void Main(string[] args)
{
// Create new esl client with api token and base url
EslClient client = new EslClient(apiToken, baseUrl);
//Get my hands on the list of signers somehow...
List <SignerInfo> signers = Signers();
//Get my hands on the list of documents somehow...
List <DocumentInfo> documents = Documents();
PackageBuilder packageBuilder = PackageBuilder.NewPackageNamed("Package with variable number of signers and documents")
.DescribedAs("This is a new package");
foreach (SignerInfo signer in signers)
{
packageBuilder.WithSigner(SignerBuilder.NewSignerWithEmail(signer.Email)
.WithFirstName(signer.FirstName)
.WithLastName(signer.LastName)
.Build());
}
foreach (DocumentInfo document in documents)
{
DocumentBuilder documentBuilder = DocumentBuilder.NewDocumentNamed(document.Name).FromFile(document.File.FullName);
foreach (SignerInfo signer in signers)
{
documentBuilder.WithSignature(SignatureBuilder.SignatureFor(signer.Email)
.OnPage(0)
.AtPosition(500, 100)
.Build());
}
}
PackageId id = client.CreatePackage(packageBuilder.Build());
client.SendPackage(id);
Console.WriteLine("Package {0} was sent", id.Id);
}
public override SignaturePart ToSignaturePart(ParameterInfo pi)
{
var constraint = Constraint.OfType(StdAtom.ATOM);
var quirks = pi.GetCustomAttributes <VariableAttribute>().Single().QuirksMode;
if ((quirks & QuirksMode.Global) != 0)
{
//XXX
constraint = constraint.Or(Constraint.OfType(StdAtom.GVAL));
}
if ((quirks & QuirksMode.Local) != 0)
{
//XXX
constraint = constraint.Or(Constraint.OfType(StdAtom.LVAL));
}
return(SignatureBuilder.Constrained(
SignatureBuilder.Identifier(pi.Name),
constraint));
}
override public void Execute()
{
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("ReminderExample: " + DateTime.Now)
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("Patty")
.WithLastName("Galant"))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(100, 100)))
.Build();
packageId = eslClient.CreatePackage(superDuperPackage);
reminderScheduleToCreate = ReminderScheduleBuilder.ForPackageWithId(packageId)
.WithDaysUntilFirstReminder(2)
.WithDaysBetweenReminders(1)
.WithNumberOfRepetitions(5)
.Build();
eslClient.ReminderService.CreateReminderScheduleForPackage(reminderScheduleToCreate);
eslClient.SendPackage(packageId);
createdReminderSchedule = eslClient.ReminderService.GetReminderScheduleForPackage(packageId);
reminderScheduleToUpdate = ReminderScheduleBuilder.ForPackageWithId(packageId)
.WithDaysUntilFirstReminder(3)
.WithDaysBetweenReminders(2)
.WithNumberOfRepetitions(10)
.Build();
eslClient.ReminderService.UpdateReminderScheduleForPackage(reminderScheduleToUpdate);
updatedReminderSchedule = eslClient.ReminderService.GetReminderScheduleForPackage(packageId);
eslClient.ReminderService.ClearReminderScheduleForPackage(packageId);
removedReminderSchedule = eslClient.ReminderService.GetReminderScheduleForPackage(packageId);
}
override public void Execute()
{
DocumentPackage superDuperPackage =
PackageBuilder.NewPackageNamed(PackageName)
.DescribedAs("This is a package created using the eSignLive SDK")
.WithSigner(SignerBuilder.NewSignerWithEmail("*****@*****.**")
.WithCustomId("Client1")
.WithFirstName("John")
.WithLastName("Smith")
)
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor("*****@*****.**")
.OnPage(0)
.AtPosition(100, 100)
)
)
.Build();
PackageId packageId = eslClient.CreateAndSendPackage(superDuperPackage);
eslClient.PackageService.Edit(packageId);
}
override public void Execute()
{
eslClient.AccountService.InviteUser(
AccountMemberBuilder.NewAccountMember(senderEmail)
.WithFirstName("firstName")
.WithLastName("lastName")
.WithCompany("company")
.WithTitle("title")
.WithLanguage("language")
.WithPhoneNumber("phoneNumber")
.Build()
);
SenderInfo customSenderInfo = SenderInfoBuilder.NewSenderInfo(senderEmail)
.WithName("firstName", "lastName")
.WithTitle("title")
.WithCompany("company")
.Build();
DocumentPackage customSenderPackage = PackageBuilder.NewPackageNamed(PackageName)
.WithSenderInfo(customSenderInfo)
.DescribedAs("This is a package created using the eSignLive SDK")
.ExpiresOn(DateTime.Now.AddMonths(1))
.WithEmailMessage("This message should be delivered to all signers")
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(senderEmail)
.OnPage(0)
.AtPosition(100, 100)))
.Build();
PackageId packageId = eslClient.CreatePackage(customSenderPackage);
string userAuthenticationToken = eslClient.AuthenticationTokenService.CreateUserAuthenticationToken();
generatedLinkToPackageViewForSender = authenticationClient.BuildRedirectToPackageViewForSender(userAuthenticationToken, packageId);
System.Console.WriteLine("PackageView redirect url: " + generatedLinkToPackageViewForSender);
}
override public void Execute()
{
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed(PackageName)
.DescribedAs("This is a package created using the eSignLive SDK")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John1")
.WithLastName("Smith1"))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(100, 100)))
.Build();
packageId = ossClient.CreatePackage(superDuperPackage);
retrievedPackage = ossClient.GetPackage(packageId);
Signer signer = retrievedPackage.GetSigner(email1);
// Create
signerVerificationToBeCreated = SignerVerificationBuilder
.NewSignerVerification(CREATE_VERIFICATION_TYPE_ID)
.WithPayload(CREATE_VERIFICATION_PAYLOAD)
.Build();
ossClient.CreateSignerVerification(packageId, signer.Id, signerVerificationToBeCreated);
retrievedSignerVerificationAfterCreate = ossClient.GetSignerVerification(packageId, signer.Id);
// Update
signerVerificationToBeUpdated = SignerVerificationBuilder
.NewSignerVerification(UPDATE_VERIFICATION_TYPE_ID)
.WithPayload(UPDATE_VERIFICATION_PAYLOAD)
.Build();
ossClient.UpdateSignerVerification(packageId, signer.Id, signerVerificationToBeUpdated);
retrievedSignerVerificationAfterUpdate = ossClient.GetSignerVerification(packageId, signer.Id);
// Delete
ossClient.DeleteSignerVerification(packageId, signer.Id);
retrievedSignerVerificationAfterDelete = ossClient.GetSignerVerification(packageId, signer.Id);
}
public MemoryStream Execute(string[] commandLineArguments, MemoryStream ms = null)
{
// Parse through arguments
options.Parse(commandLineArguments);
// Check if the file path contains a string
if (string.IsNullOrWhiteSpace(basisFilePath))
{
throw new OptionException("No basis file was specified", "basis-file");
}
// Specifiy new files path
basisFilePath = Path.GetFullPath(basisFilePath);
// Set up the signature generator (load options)
var signatureBuilder = new SignatureBuilder();
foreach (var config in configuration)
{
config(signatureBuilder);
}
// Check if the file exists
if (!File.Exists(basisFilePath))
{
throw new FileNotFoundException("File not found: " + basisFilePath, basisFilePath);
}
// Generate signature from file
using (var basisStream = new FileStream(basisFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var signatureStream = new MemoryStream())//FileStream(signatureFilePath, FileMode.Create, FileAccess.Write, FileShare.Read))
{
signatureBuilder.Build(basisStream, new SignatureWriter(signatureStream));
// Return stream containing signature
return(signatureStream);
}
}
public static void Main(string[] args)
{
// Create new esl client with api token and base url
EslClient client = new EslClient(apiToken, baseUrl);
FileInfo file = new FileInfo(Directory.GetCurrentDirectory() + "/src/document.pdf");
DocumentPackage package = PackageBuilder.NewPackageNamed("Fields example " + DateTime.Now)
.DescribedAs("This is a new package")
.WithSigner(SignerBuilder.NewSignerWithEmail("*****@*****.**")
.WithFirstName("John")
.WithLastName("Smith")
.WithCompany("Acme Inc")
.WithTitle("Managing Director"))
.WithDocument(DocumentBuilder.NewDocumentNamed("My Document")
.FromFile(file.FullName)
.WithSignature(SignatureBuilder.SignatureFor("*****@*****.**")
.OnPage(0)
.AtPosition(500, 100)
.WithField(FieldBuilder.SignatureDate()
.OnPage(0)
.AtPosition(500, 200))
.WithField(FieldBuilder.SignerName()
.OnPage(0)
.AtPosition(500, 300))
.WithField(FieldBuilder.SignerTitle()
.OnPage(0)
.AtPosition(500, 400))
.WithField(FieldBuilder.SignerCompany()
.OnPage(0)
.AtPosition(500, 500))))
.Build();
PackageId id = client.CreatePackage(package);
client.SendPackage(id);
Console.WriteLine("Package {0} was sent", id.Id);
}
override public void Execute()
{
string customFieldId = Guid.NewGuid().ToString().Replace("-", "");
Console.WriteLine("customer field ID = " + customFieldId);
CustomField customField = eslClient.GetCustomFieldService()
.CreateCustomField(CustomFieldBuilder.CustomFieldWithId(customFieldId)
.WithDefaultValue("#12345")
.WithTranslation(TranslationBuilder.NewTranslation("en").
WithName("Player Number").
WithDescription("The number on your team jersey"))
.WithTranslation(TranslationBuilder.NewTranslation("fr").
WithName("Numéro du Joueur").
WithDescription("Le numéro dans le dos de votre chandail d'équipe"))
.Build());
CustomFieldValue customFieldValue = eslClient.GetCustomFieldService()
.SubmitCustomFieldValue(CustomFieldValueBuilder.CustomFieldValueWithId(customField.Id)
.WithValue("99")
.build());
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed("Sample Insurance policy")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("John")
.WithLastName("Smith"))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(documentInputStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(100, 100)
.WithField(FieldBuilder.CustomField(customFieldValue.Id)
.OnPage(0)
.AtPosition(400, 200))))
.Build();
PackageId packageId = eslClient.CreatePackage(superDuperPackage);
eslClient.SendPackage(packageId);
}
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);
}
override public void Execute()
{
CapturedSignature capturedSignature = new CapturedSignature("AQAAAIPGDPtxqL+RsL7/w/7eEX+cAtwAAwADAFAAAAADAAAAnALcACMAAAACq5ZQg105VH9Z/1l+UM9QF3A0v3BEv2BmYYFgSGAYQBZAJkA0QDVAREBmQENAQ0BRUJFQg1CDUFKbQENASUBGQERFUA==");
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed(PackageName)
.WithSettings(DocumentPackageSettingsBuilder.NewDocumentPackageSettings().WithInPerson())
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithCustomId(signer1Id)
.WithFirstName("John1")
.WithLastName("Smith1"))
.WithDocument(DocumentBuilder.NewDocumentNamed(document1Name)
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.CaptureFor(senderEmail)
.OnPage(0)
.AtPosition(100, 100))
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(400, 100)))
.WithDocument(DocumentBuilder.NewDocumentNamed(document2Name)
.FromStream(fileStream2, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(senderEmail)
.OnPage(0)
.AtPosition(100, 100))
.WithSignature(SignatureBuilder.CaptureFor(email1)
.OnPage(0)
.AtPosition(400, 100)))
.Build();
packageId = ossClient.CreatePackage(superDuperPackage);
ossClient.SendPackage(packageId);
RetrievedPackageBeforeSigning = ossClient.GetPackage(packageId);
ossClient.SignDocuments(packageId, capturedSignature);
retrievedPackageAfterSigningApproval1 = ossClient.GetPackage(packageId);
ossClient.SignDocuments(packageId, signer1Id, capturedSignature);
retrievedPackageAfterSigningApproval2 = ossClient.GetPackage(packageId);
}
public ChunkedSignatureTests()
{
ServiceCollection services = new ServiceCollection();
services.AddLogging();
SimpleS3CoreServices.AddSimpleS3Core(services).UseAmazonS3(x =>
{
x.Credentials = new StringAccessKey("AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY");
x.Region = AmazonS3Region.UsEast1;
//The tests here have signatures built using path style
x.NamingMode = NamingMode.PathStyle;
});
ServiceProvider?provider = services.BuildServiceProvider();
_scopeBuilder = (ScopeBuilder)provider.GetRequiredService <IScopeBuilder>();
_sigBuilder = (SignatureBuilder)provider.GetRequiredService <ISignatureBuilder>();
_chunkedSigBuilder = (ChunkedSignatureBuilder)provider.GetRequiredService <IChunkedSignatureBuilder>();
_authBuilder = provider.GetRequiredService <HeaderAuthorizationBuilder>();
_config = provider.GetRequiredService <IOptions <SimpleS3Config> >().Value;
}
override public void Execute()
{
DocumentPackage template =
PackageBuilder.NewPackageNamed("CreateSenderTemplateExample: " + DateTime.Now)
.DescribedAs("This is a Template created using the eSignLive SDK")
.WithVisibility(visibility)
.WithEmailMessage("This message should be delivered to all signers")
.WithSigner(SignerBuilder.NewSignerWithEmail(email1)
.WithFirstName("Patty")
.WithLastName("Galant"))
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.WithId("documentId")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(400, 200)
))
.Build();
templateId = ossClient.CreateTemplate(template);
Console.WriteLine("templateId = " + templateId);
}
public SignatureBenchmarks()
{
S3Config config = new S3Config(new StringAccessKey("AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"), AwsRegion.USEast1);
config.EnableStreaming = false;
IOptions <S3Config> options = Options.Create(config);
S3ConfigNullCredentialProvider nullCredsProvider = new S3ConfigNullCredentialProvider(options);
_signingKeyBuilder = new SigningKeyBuilder(options, nullCredsProvider, NullLogger <SigningKeyBuilder> .Instance);
IScopeBuilder scopeBuilder = new ScopeBuilder(options);
_signatureBuilder = new SignatureBuilder(_signingKeyBuilder, scopeBuilder, NullLogger <SignatureBuilder> .Instance);
_chunkSigBuilder = new ChunkedSignatureBuilder(_signingKeyBuilder, scopeBuilder, NullLogger <ChunkedSignatureBuilder> .Instance);
byte[] data = Encoding.UTF8.GetBytes("Hello world");
_req = new PutObjectRequest("examplebucket", "benchmark", new MemoryStream(data));
_req.AddHeader(AmzHeaders.XAmzContentSha256, CryptoHelper.Sha256Hash(data).HexEncode());
_date = DateTimeOffset.UtcNow;
}
override public void Execute()
{
Signer signer1 = SignerBuilder.NewSignerWithEmail(email1)
.WithCustomId("signer1")
.WithFirstName("John1")
.WithLastName("Smith1").Build();
DocumentPackage superDuperPackage = PackageBuilder.NewPackageNamed(PackageName)
.WithSettings(DocumentPackageSettingsBuilder.NewDocumentPackageSettings().WithInPerson())
.WithSigner(signer1)
.WithDocument(DocumentBuilder.NewDocumentNamed("First Document")
.FromStream(fileStream1, DocumentType.PDF)
.WithSignature(SignatureBuilder.SignatureFor(email1)
.OnPage(0)
.AtPosition(100, 100)))
.Build();
packageId = ossClient.CreatePackage(superDuperPackage);
ossClient.SendPackage(packageId);
ossClient.SignatureImageService.GetSignatureImageForSender(senderUID, SignatureImageFormat.GIF);
ossClient.SignatureImageService.GetSignatureImageForPackageRole(packageId, signer1.Id, SignatureImageFormat.JPG);
}
public static void MainSignature()
{
Signature s;
bool result;
SignatureBuilder sb = new SignatureBuilder();
System.Diagnostics.Stopwatch sw;
sw = new System.Diagnostics.Stopwatch();
sb.AddNewFromDelegate(new DoubleEventHandler(Doble));
sb.AddNewFromDelegate(new VoidEventHandler(Vacio));
sb.AddNewFromDelegate(new DosDobles(Suma));
sb.AddNewFromDelegate(new DoubleArrayDelegate(DoubleArray));
sb.AddNewFromDelegate(new StringArrayEventHandler(StringArray));
//Console.WriteLine(sb.RegexPattern);
s = sb.GenerateSignature("command");
Command cmd = new Command("command", "Hola Mundo!");
sw.Start();
result = s.CallIfMatch(cmd);
sw.Stop();
Console.WriteLine("Elapsed: " + sw.ElapsedMilliseconds);
cmd.Parameters = "";
result = s.CallIfMatch(cmd);
cmd.Parameters = "3";
result = s.CallIfMatch(cmd);
cmd.Parameters = "3.141592 2.71";
result = s.CallIfMatch(cmd);
cmd.Parameters = "3.141592 2.71 3.141592 2.71 3.141592 2.71 3.141592 2.71 3.141592 2.71";
result = s.CallIfMatch(cmd);
Response rsp = Response.CreateFromCommand(cmd, false);
rsp.Parameters = "3.1416 1";
SignatureAnalysisResult sar = s.Analyze(rsp);
double a = 0;
double b = 0;
sar.Update("d1", ref a);
Console.WriteLine("a: " + a.ToString());
sar.GetParameter("d2", out b);
Console.WriteLine("b: " + b.ToString());
sar.Execute();
Console.WriteLine();
Console.WriteLine("Ejecutando Benchmark");
//TextWriter cout = Console.Out;
//Console.SetOut(TextWriter.Null);
//Thread thread = new Thread(new ThreadStart(new VoidEventHandler(delegate()
//{
// while (true) { sar = s.Analyze(rsp); sar.Execute(); }
//})));
//i = 0;
//thread.Start();
//Thread.Sleep(1000);
//thread.Abort();
sb.Clear();
sb.AddNewFromDelegate(new DosDobles(Nothing));
sb.AddNewFromDelegate(new VoidEventHandler(Nothing));
s = sb.GenerateSignature("command");
rsp = new Response("command", "1 2", true, -1);
TimeSpan total = new TimeSpan(0);
sw = new Stopwatch();
sar = s.Analyze(rsp);
for (int count = 0; count < 100; ++count)
{
Console.Write("\r");
Console.Write(count);
Console.Write("%\t");
sw.Reset();
sw.Start();
for (i = 0; i < 100000; ++i)
{
sar.Execute();
}
sw.Stop();
total +=sw.Elapsed;
}
Console.WriteLine();
total = new TimeSpan(total.Ticks / 100);
//Console.SetOut(cout);
Console.WriteLine("Ejecutado 100 veces 100k ciclos. Promedio de rafaga: " + total.TotalMilliseconds + "ms");
Console.WriteLine("Promedio de ejecucion: " + (total.TotalMilliseconds/(100.0)) + "us");
//s.Parse(null, a, b, c);
}
/// <summary>
/// Creates the Man Signatures
/// </summary>
private void CreateManipulatorSignatures()
{
SignatureBuilder sb = new SignatureBuilder();
//sgnManGoTo = sb.GenerateSignature("manGoto");
//sb.Clear();
sb.AddNewFromTypes(typeof(int));
sb.AddNewFromTypes();
sgnOpenGrip = sb.GenerateSignature("man_open");
sgnCloseGrip = sb.GenerateSignature("man_close");
sb.Clear();
sb.AddNewFromTypes(typeof(double));
sb.AddNewFromTypes();
sgnTilt = sb.GenerateSignature("man_tilt");
sb.Clear();
sb.AddNewFromTypes(typeof(int), typeof(double));
sb.AddNewFromTypes();
sgnStatus = sb.GenerateSignature("man_status");
}
/// <summary>
/// Creates the Arm Signatures
/// </summary>
private void CreateArmSignatures()
{
SignatureBuilder sb = new SignatureBuilder();
//sgnArmGoTo = sb.GenerateSignature("armGoto");
//sb.Clear();
sb.AddNewFromTypes(typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double));
sgnArmGetAbsPos = sb.GenerateSignature("ra_abspos");
sb.AddNewFromTypes(typeof(double), typeof(double), typeof(double), typeof(double), typeof(double), typeof(double));
sb.AddNewFromTypes(typeof(double), typeof(double), typeof(double));
sgnArmSetAbsPos = sb.GenerateSignature("ra_abspos");
sgnArmSetRelPos = sb.GenerateSignature("ra_relpos");
sb.Clear();
sb.AddNewFromTypes(typeof(double), typeof(double), typeof(double));
sgnArmSetOrientation = sb.GenerateSignature("ra_orientation");
sgnArmGetOrientation = sb.GenerateSignature("ra_orientation");
sb.Clear();
sb.AddNewFromTypes(typeof(int));
sb.AddNewFromTypes();
sgnArmOpenGrip = sb.GenerateSignature("ra_opengrip");
sgnArmCloseGrip = sb.GenerateSignature("ra_closegrip");
sb.Clear();
sb.AddNewFromTypes(typeof(string));
sgnArmGoTo = sb.GenerateSignature("ra_goto");
sgnArmMove = sb.GenerateSignature("ra_move");
sgnArmTorque = sb.GenerateSignature("ra_torque");
}
/// <summary>
/// Creates the Arm Signatures
/// </summary>
private void CreateHeadSignatures()
{
SignatureBuilder sb = new SignatureBuilder();
sb.AddNewFromTypes(typeof(double), typeof(double), typeof(double));
sb.AddNewFromTypes(typeof(double), typeof(double));
sgnHeadLookAt = sb.GenerateSignature("hd_lookat");
sb.Clear();
sb.AddNewFromTypes(typeof(string), typeof(double));
sb.AddNewFromTypes(typeof(string));
sgnHeadShow = sb.GenerateSignature("hd_show");
}
