En este post voy a explicarte cómo puedes consumir el plugin de impresoras térmicas y así poder imprimir desde cualquier lenguaje de programación que hable HTTP.

Como bien sabes, mi plugin no es más que un servidor web que te permite imprimir en impresoras POS, solo debes indicarle las operaciones que debe hacer.

Veamos entonces cómo imprimir en una impresora térmica usando cualquier lenguaje de programación y mi plugin gratuito.

API actualizada

Entre tantas actualizaciones del plugin he tratado de unificar la API y hacer un sitio único para describir todas las operaciones, colocar una área de pruebas con ejemplo de código y mantenerlo actualizando junto con el plugin: https://parzibyte.me/http-esc-pos-desktop-docs/es/

Te recomiendo revisar la API actualizada pues es el sitio que tiene la información más reciente. De ese modo me evitaré actualizar cada post que he escrito, pues la única fuente de verdad será la documentación de la API HTTP a ESC POS.

Documentación de la API del servidor

En el siguiente sitio vas a encontrar la documentación completa para imprimir, obtener la versión del plugin, detenerlo, obtener la lista de impresoras o reenviar la información.

https://parzibyte.me/http-esc-pos-desktop-docs/es/api/introduccion.html

El servidor expone 3 rutas. Pero qué mejor que el código las explique por sí mismo:

enrutador.HandleFunc("/reenviar", handlerHttpReenviar).Methods(http.MethodGet, http.MethodPost)
enrutador.HandleFunc("/imprimir", handlerHttpImprimir).Methods(http.MethodPost)
enrutador.HandleFunc("/impresoras", handlerHttpObtenerImpresoras).Methods(http.MethodGet)

La primer ruta es para reenviar la información y que el plugin funcione como proxy como ya lo expliqué en otro post.

Por otro lado si quieres imprimir debes invocar a la ruta /imprimir con el método post enviando un struct así:

type ImpresionConNombre struct {
 Operaciones     []OperacionEscpos `json:"operaciones"`
 NombreImpresora string            `json:"nombreImpresora"`
 Serial          string            `json:"serial"`
}

Por cierto, la OperacionEscpos se define así:

type OperacionEscpos struct {
 Nombre     string        `json:"nombre"`
 Argumentos []interface{} `json:"argumentos"`
}

Nota: en este caso el nombre de operación debe ser una definida en la documentación. Es importante que conozcas la lista completa:

Como puedes ver, los argumentos son un arreglo de cualquier longitud y cualquier tipo.

Finalmente si invocas a GET /impresoras obtendrás las impresoras compartidas disponibles para el plugin.

El servidor te devolverá un arreglo de tipo string, en donde cada elemento es el nombre de una impresora.

Creando conector para cualquier lenguaje

Entonces lo que necesitas en tu lenguaje de programación es:

1. Un cliente HTTP que permita hacer peticiones GET y POST
2. Poder codificar y decodificar JSON

Eso es todo lo que necesitas.

Para el cliente HTTP en Java por ejemplo tenemos a HttpClient, en JavaScript a fetch, para Python existe requests, en Golang contamos con http.Client y en todos los lenguajes debe haber un equivalente.

Ejemplo: imprimir en impresora térmica con HTTP y JSON

Veamos un ejemplo del JSON que debemos enviar para iniciar, cambiar la alineación, escribir texto, un código de barras y recorrer el papel:

{
    "serial": "",
    "nombreImpresora": "Termica",
    "operaciones": [
        {
            "nombre": "Iniciar",
            "argumentos": []
        },
        {
            "nombre": "EstablecerAlineacion",
            "argumentos": [
                1
            ]
        },
        {
            "nombre": "EscribirTexto",
            "argumentos": [
                "Hola impresora\n"
            ]
        },
        {
            "nombre": "ImprimirCodigoDeBarrasCode39",
            "argumentos": [
                "123",
                true,
                true,
                20,
                380,
                0
            ]
        },
        {
            "nombre": "Iniciar",
            "argumentos": []
        },
        {
            "nombre": "Feed",
            "argumentos": [
                2
            ]
        }
    ]
}

Recuerda que será un objeto con las propiedades operaciones, nombreImpresora y serial.

Las operaciones serán un arreglo de objetos que deben tener dos propiedades: nombre y argumentos. nombre es de tipo string y argumentos es un arreglo que puede tener 0 o infinitos argumentos.

Los nombres de las operaciones los he tomado de la documentación al igual que el número de argumentos. Las operaciones que no toman argumentos reciben un arreglo vacío, pero incluso así debes especificarlo.

Al enviar ese JSON con Postman aparecerá el ticket que viste arriba. Tú puedes probarlo en el playground.

Fíjate en el cuerpo que estoy enviando (aunque Postman lo hace bonito, recuerda que tú debes enviarlo como un JSON normal sin justificar o alinear).

La respuesta del servidor será un objeto JSON que tiene la propiedad ok de tipo booleana y la propiedad message de tipo cadena. Si ok está en true, entonces todo fue bien. De lo contrario, el mensaje de error estará en la propiedad message como se describe en la API.

Por cierto, Postman te permite generar el código para varios lenguajes. Puedes revisar si el código generado funciona para ti.

Lo que yo recomiendo es que hagas una lista de operaciones que vas a enviar al plugin, al final es un arreglo. Luego, envía ese arreglo en la propiedad operaciones de la carga útil al imprimir como se describe en la documentación.

Al final tú decides cómo formas el JSON, puedes incluso hacerlo concatenando cadenas.

Te recomiendo ver la descripción de la API que contiene todas las operaciones y generación de código.

Vídeo de apoyo

Si quieres puedes ver la explicación en vídeo para complementar lo expuesto por escrito: