OneSpan Sign Como: Criando um Modelo

Haris Haidary, 22 de Dezembro de 2015
Thumbnail

Os modelos permitem que um remetente crie rapidamente um novo pacote de documentos usando um anterior como blueprint. É uma ótima ferramenta se você planeja enviar os mesmos documentos para assinar regularmente. Neste blog, mostrarei como criar um modelo a partir do zero e a partir de um pacote existente usando o OneSpan Sign Java SDK, .NET SDK e REST API.

Modelos na interface do usuário

Para começar, você deve localizar a seção de modelos na sua interface do usuário. Após fazer login na sua conta OneSpan Sign, clique em TEMPLATES na barra de ferramentas. Depois de executar seu código, você deve encontrar seus modelos salvos aqui.

uitemplate

O código

Como mencionei antes, mostrarei como fazer isso com o OneSpan Sign Java SDK, .NET SDK e REST API. Você pode ir em frente e pular para a seção que se aplica a você. Vou cobrir exatamente as mesmas informações em todas as seções. No meu exemplo, mostrarei como criar um modelo com um documento e dois assinantes. O código de exemplo completo deste blog pode ser encontrado no Compartilhamento de código da comunidade de desenvolvedores ( Java , .INTERNET , DESCANSAR ) [ID da promoção = "14439"] JAVA SDK Primeiro, começarei com o Java SDK. O código de exemplo abaixo cria um modelo do zero, com um documento e dois assinantes. A primeira etapa é criar seu cliente OneSpan Sign. Certifique-se de substituir os espaços reservados API_KEY e API_URL pelos seus valores. Posteriormente, você constrói seu pacote de documentos com as propriedades aplicáveis. Depois que seu pacote é criado, você chama seu TemplateService para criar seu modelo.

pacote com.esignlive.example;

importar com.silanis.esl.sdk.DocumentPackage;
import com.silanis.esl.sdk.EslClient;
importar com.silanis.esl.sdk.PackageId;
 
importar estático com.silanis.esl.sdk.builder.DocumentBuilder.newDocumentWithName;
importar estático com.silanis.esl.sdk.builder.PackageBuilder.newPackageNamed;
importar estático com.silanis.esl.sdk.builder.SignatureBuilder.signatureFor;
importar estático com.silanis.esl.sdk.builder.SignerBuilder.newSignerWithEmail;

Modelos de classe pública {
	
    public static final String API_KEY = "your_api_key";
    public static final String API_URL = "https://sandbox.e-signlive.com/api"; 
    // USE https://apps.e-signlive.com/api PARA PRODUÇÃO
 
    public static void main (String [] args) {
    	
    	EslClient eslClient = novo EslClient (API_KEY, API_URL);
    	
    	DocumentPackage documentPackage = newPackageNamed ("Meu modelo do Java SDK do zero") 
    					.withSigner (newSignerPlaceholder (novo Placeholder ("PlaceholderId1")))) 
    					.withSigner (newSignerPlaceholder (novo Placeholder ("PlaceholderId2"))))
    					.withDocument (newDocumentWithName ("Meu documento") 
    							.fromFile ("YOUR_FILE_PATH") 
    							.withSignature (signatureFor (new Placeholder ("PlaceholderId1"))) 
    									.emPágina (0) 
    									.atPosition (100, 140))
    							.withSignature (signatureFor (new Placeholder ("PlaceholderId2")))
    									.emPágina (0) 
    									.atPosition (100, 205)))
    					.Construir();
    	
    	PackageId templateId = eslClient.getTemplateService (). CreateTemplate (documentPackage);
    }

}

Você também pode criar um modelo a partir de um pacote existente. Para isso, você precisará do packageId do seu pacote.

PackageId packageId = new PackageId ("d9355f04-9bb2-4219-b9fa-734f2650a939");
PackageId templateFromPackage = eslClient.getTemplateService (). CreateTemplateFromPackage (packageId, "Novo modelo do pacote");

.NET SDK Em seguida, examinarei o .NET SDK. O código de exemplo abaixo cria um modelo do zero, com um documento e dois assinantes. A primeira etapa é criar seu cliente OneSpan Sign. Certifique-se de substituir os espaços reservados API_KEY e API_URL pelos seus valores. Posteriormente, você constrói seu pacote de documentos com as propriedades aplicáveis. Depois que seu pacote é criado, você chama seu TemplateService para criar seu modelo.

using System;
using System.IO;
using Silanis.ESL.SDK;
using Silanis.ESL.SDK.Builder;

namespace createTemplateFrom
{
    classe createTemplateFrom
    {
        string estática privada apiUrl = "https://sandbox.e-signlive.com/api";
        // USE https://apps.e-signlive.com/api PARA PRODUÇÃO
        string estática privada apiKey = "your_api_key";

        public static void Main (string [] args)
        {
            EslClient eslClient = novo EslClient (apiKey, apiUrl);

            FileStream fs = File.OpenRead ("YOUR_FILE_PATH");

           DocumentPackage documentPackage = PackageBuilder
                    .NewPackageNamed ("Meu modelo do zero .NET SDK")
                    .WithSigner (SignerBuilder.NewSignerPlaceholder (novo espaço reservado ("PlaceholderId1"))))
                    .WithSigner (SignerBuilder.NewSignerPlaceholder (novo espaço reservado ("PlaceholderId2"))))
                    .WithDocument (DocumentBuilder.NewDocumentNamed ("Meu documento")
                                  .FromStream (fs, DocumentType.PDF)
                                  .WithSignature (SignatureBuilder
                                       .SignatureFor (new Placeholder ("PlaceholderId1"))
                                         .OnPage (0)
                                         .AtPosition (100, 140))
                                  .WithSignature (SignatureBuilder
                                       .SignatureFor (new Placeholder ("PlaceholderId2"))
                                         .OnPage (0)
                                         .AtPosition (100, 205)))
                    .Construir();

            PackageId templateId = eslClient.CreateTemplate (documentPackage);
        }
    }
}

Você também pode criar um modelo a partir de um pacote existente. Para fazer isso, você precisará do packageId do seu pacote.

PackageId packageId = new PackageId ("d9355f04-9bb2-4219-b9fa-734f2650a939");
PackageId templateFromPackage = eslClient.CreateTemplateFromPackage (packageId, "Novo modelo do pacote");

API REST Por fim, mostrarei como fazer isso com a API REST. Abaixo está uma classe C # que faz uma solicitação POST para criar um novo modelo do zero. A carga útil da solicitação JSON contém muitas propriedades vazias que não são necessárias para criar um novo modelo. Incluí-os para fornecer uma lista de opções disponíveis e como elas são analisadas no JSON.

using System;
using System.Diagnostics;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;

namespace createTemplateREST
{
    classe pública createTemplateREST
    {
        public static void Main (string [] args)
        {

            string apiKey = "your_api_key";
            string url = "https://sandbox.e-signlive.com/api";

            string jsonString = "{\" name \ ": \" Meu modelo do zero REST \ ", \" description \ ": \" \ ", \" functions \ ": [{\" name \ ": \" PlaceholderId1 \ ", \" index \ ": 0, \" id \ ": \" PlaceholderId1 \ ", \" locked \ ": false, \" reatribuir \ ": false}, {\" name \ ": \" PlaceholderId2 \ ", \" index \ ": 0, \" id \ ": \" PlaceholderId2 \ ", \" locked \ ": false, \" reatribuir \ ": false}], \" type \ ": \" TEMPLATE \ ", \" devido \ ": nulo, \" preenchimento automático \ ": verdadeiro, \" emailMessage \ ": \" \ ", \" documents \ ": [{\" approvals \ ": [{\" role \ " : \ "PlaceholderId1 \", \ "assinado \": nulo, \ "aceito \": nulo, \ "dados \": nulo, \ "campos \": [{\ "page \": 0, \ "subtipo \ ": \" FULLNAME \ ", \" width \ ": 200, \" binding \ ": null, \" extract \ ": false, \" extractAnchor \ ": null, \" left \ ": 175, \ "top \": 165, \ "validação \": null, \ "height \": 50, \ "data \": null, \ "type \": \ "SIGNATURE \", \ "value \": \ "\"}], \ "nome \": \ "\"}, {\ "papel \": \ "PlaceholderId2 \", \ "assinado \": nulo, \ "aceito \": nulo, \ "dados \ ": null, \" fields \ ": [{\" page \ ": 0, \" subtipo \ ": \" FULLNAME \ ", \" width \ ": 200, \" binding \ ": null, \ "extrair \": false, \ "extrairAnchor \": null , \ "left \": 550, \ "top \": 165, \ "validation \": null, \ "height \": 50, \ "data \": null, \ "type \": \ "SIGNATURE \ ", \" value \ ": \" \ "}], \" name \ ": \" \ "}], \" name \ ": \" YOUR_FILE_NAME \ "}]}";
            
            StringContent jsonContent = novo StringContent (jsonString, Encoding.UTF8, "application / json"); 

            byte [] fileByteArray = File.ReadAllBytes ("YOUR_FILE_PATH");
            Conteúdo ByteArrayContent = novo ByteArrayContent (fileByteArray);

            content.Headers.ContentDisposition = new ContentDispositionHeaderValue ("form-data");
            content.Headers.ContentDisposition.Name = "\" arquivo \ "";
            content.Headers.ContentDisposition.FileName = "\" myDocument.pdf \ "";
            content.Headers.ContentType = new MediaTypeHeaderValue ("application / pdf");

            Formulário MultipartFormDataContent = new MultipartFormDataContent ();
            form.Add (content, "\" file \ "", "\" myDocument.pdf \ "");
            form.Add (jsonContent, "\" carga \ "");

            HttpClient myClient = new HttpClient ();
            myClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue ("Basic", apiKey);
            myClient.DefaultRequestHeaders.Add ("Accept", "application / json");

            var resposta = myClient.PostAsync (novo Uri (url) + "/ packages /", formulário) .Result;
            Debug.WriteLine (response.Content.ReadAsStringAsync (). Result);
        }
    }
}

Da mesma forma, você pode criar um novo modelo a partir de um pacote existente. Você precisará do packageId do pacote que deseja clonar.

string jsonString = "{\" name \ ": \" your_cloned_template \ ", \" description \ ": \" \ ", \" emailMessage \ ": \" \ ", \" preenchimento automático \ ": true, \" configurações \ ": {\" ceremony \ ": {\" inPerson \ ": false}}, \" type \ ": \" TEMPLATE \ ", \" remetente \ ": {\" lastName \ ": \" Sender_Last_Name \ ", \" firstName \ ": \" Sender_First_Name \ ", \" email \ ": \" first.signer @example .com \ "}, \" visibilidade \ ": \" CONTA \ ", \" devido \ ": nulo, \" idioma \ ": \" en \ "}";
StringContent jsonContent = novo StringContent (jsonString, Encoding.UTF8, "application / json");

HttpClient myClient = new HttpClient ();
myClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue ("Basic", apiKey);
myClient.DefaultRequestHeaders.Add ("Accept", "application / json");

resposta var = myClient.PostAsync (new Uri (url + "d9355f04-9bb2-4219-b9fa-734f2650a939 / clone"), jsonContent) .Result;
Debug.WriteLine (response.Content.ReadAsStringAsync (). Result);

Executando seu código

Vá em frente e execute seu código. Você poderá ver o modelo recém-criado na sua conta do OneSpan Sign.

modelo de resultados

Ai está. Você criou com sucesso um modelo do zero e de um pacote criado anteriormente.

Se você tiver dúvidas sobre este blog ou qualquer outra coisa relacionada à integração do OneSpan Sign ao seu aplicativo, visite os fóruns da comunidade de desenvolvedores: https://developer.onespan.com . É isso de mim. Obrigado pela leitura! Se você achou esta publicação útil, compartilhe-a no Facebook, Twitter ou LinkedIn.

Haris Haidary Junior

Evangelista Técnico de Produtos

LinkedIn | Twitter