Probando a firmar documentos con Docuten
Tags: groovy, docuten, spanish
Published: 2023-12-07 07:01:28

---
title: Probando a firmar documentos con Docuten
published: true
date: 2023-12-05 00:00:00 UTC
tags: groovy,docuten, spanish
canonical_url: https://jorge.aguilera.soy/blog/2023/probando-docuten.html
---

Recientemente, he empezado a colaborar con la plataforma de Firma y Factura electrónica de Docuten.

Básicamente, es un servicio SAAS para empresas y su función es gestionar todo lo relativo a la firma digital de documentos (contratos, recibos, etc.) así como la factura electrónica.

Una vez que te das de alta en la plataforma, puedes por ejemplo subir documentos para ser firmados por otra persona. Esta persona recibe un correo con un enlace al documento, puede abrirlo y si está de acuerdo puede aceptarlo introduciendo un código OTP que recibe en un segundo correo (existen más métodos de autentificación, pero este es muy simple)

Como todo buen SAAS, tiene un API bastante simple de usar y es el que voy a usar en este post para crear un caso de uso inventado.

<dl>
<dt>WARNING</dt>
<dd>
<p>Actualmente, NO puedes crearte tus propios ApiToken, sino que tienes que pedírselo al admin para que te lo
creen. En este post, parto de que ya tienes tu token (y no lo compartes con nadie que no sea de confianza)</p>
</dd>
</dl>

## Caso de Uso

Queremos crear un documento PDF "al vuelo" y enviárselo al email de alguien para que lo firme.

Queremos que el documento se guarde en la plataforma de Docuten y que podamos consultarlo una vez firmado

<dl>
<dt>WARNING</dt>
<dd>
<p>Como viene siendo habitual en este blog, son solamente ideas para ver cómo integrar las piezas,
pocas veces es un caso de uso real.</p>
</dd>
</dl>

Para este caso de uso vamos a crear un simple script de Groovy desde el que crearemos y enviaremos el pdf a Docuten.

## Parámetros de entrada

```
email = args[0]
accessToken = args[1]
label = args.length > 2 ? args[2] : "firmar asciidoctor"
url = args.length > 3 ? args[3] : 'https://sandbox.docuten.com'
```

Vamos a hacer que el script pida para ejecutarse como parámetros:

- el email de quien debe firmar

- el token proporcionado por Docuten que nos identifica

- una etiqueta para el documento

- la url del entorno (puede ser sandbox para hacer pruebas por ejemplo)

## Crear un pdf con Asciidoctor

Crear un pdf a partir de un texto es realmente sencillo con Groovy y las librerías Java de Asciidoctor

```
@GrabConfig(systemClassLoader = true)
@Grab('org.asciidoctor:asciidoctorj:2.5.7')
@Grab('org.asciidoctor:asciidoctorj-pdf:2.3.9')

import org.asciidoctor.Asciidoctor
import org.asciidoctor.Options
import org.asciidoctor.SafeMode

adoc = """= Titulo

Hola caracola

Hoy es ${new Date()} y `2*2` siguen siendo ${2*2}

"""

try (Asciidoctor asciidoctor = Asciidoctor.Factory.create()) {
    def file = Files.createTempFile("docuten", ".adoc")
    file.text = adoc.toString()

    def pdf = Files.createTempFile("docuten", ".pdf")

    asciidoctor.convertFile(file.toFile(), Options.builder()
            .safe(SafeMode.UNSAFE)
            .toFile(pdf)
            .backend("pdf")
            .build());

    // ...
}
```

Como es un ejemplo simple, construimos un texto en Asciidoctor de forma dinámica y lo convertimos a PDF generándolo en un fichero temporal.

## Enviar a Docuten

Para enviar a Docuten un fichero para firmar simplemente necesitas un Api-Token (que te proporcionan una vez te des de alta en la plataforma) y enviar un payload mediante POST

```
def payload = [
        "document": [
                "file_name" : pdf.name,
                "title" : label,
                "content" : pdf.bytes.encodeBase64().toString(),
                "description": "Toma toma toma",
                "language" : "ES",
        ],
        "signer" : [
                [
                        "email" : email,
                        "allow_historic" : "true",
                        "mobile" : "",
                        "language" : "ES",
                        "allow_reject" : "true",
                        "signature_type" : "OTP",
                        "allow_download" : "true",
                        "allow_delegate" : "false",
                        "allow_download_signed" : "true",
                        "allow_sign" : "true",
                        "name" : "jorge",
                        "allow_download_evidence": "true",
                        "redirect_url" : ""
                ]
        ],
        "metadata": [[:]],
]

def request = HttpRequest.newBuilder()
        .uri(URI.create("$url/api/v1/documents"))
        .POST(HttpRequest.BodyPublishers.ofString(JsonOutput.toJson(payload)))
        .header('Authorization', "Basic ${accessToken}")
        .header('Content-Type', "application/json")
        .build();

def response = HttpClient.newHttpClient()
        .send(request, HttpResponse.BodyHandlers.ofString())

def json = new JsonSlurper().parseText(response.body())
println json
```

Como puedes ver, el payload a enviar permite enviar el documento a una lista de personas para que todas firmen el documento y además cada una puede usar un método diferente para firmar.

En este ejemplo solo vamos a enviárselo a un email, que pasaremos por argumento

## Ejecución

Así es tan simple como ejecutar

`groovy docuten.groovy mi_customer@email.com 12345678790abc`

y tu cliente recibirá un pdf para ser firmado

## Conclusión

En futuros post espero poder investigar un poco más el API para ver cómo completar la integración de sistemas con la plataforma.

Por ejemplo una clinica veterinaria podría enviar los resultados de un análisis al email de un cliente y una vez firmado por este proceder a la intervención.

O un taller mecánico podría enviar la propuesta de un arreglo, etc