En este post voy a explicarte cómo puedes crear un conector para 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.

Documentación de la API del servidor

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:

Documentación Plugin ESC POS Desktop

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 (recuerda que no todas son térmicas).

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:

{
    "operaciones": [
        {
            "nombre": "Iniciar",
            "argumentos": []
        },
        {
            "nombre": "EstablecerAlineacion",
            "argumentos": [
                1
            ]
        },
        {
            "nombre": "EscribirTexto",
            "argumentos": [
                "Hola mundo desde Postman!\nUn barcode:\n"
            ]
        },
        {
            "nombre": "ImprimirCodigoDeBarrasCode39",
            "argumentos": [
                "123",
                true,
                true,
                100,
                320,
                0
            ]
        },
        {
            "nombre": "Iniciar",
            "argumentos": []
        },
        {
            "nombre": "Feed",
            "argumentos": [
                2
            ]
        }
    ],
    "nombreImpresora": "PT210",
    "serial": ""
}

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:

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) y la respuesta del servidor que es un true en caso de que todo vaya bien.

Si cometes un error, la impresora no existe, la operación no existe o cosas similares se te va a devolver una cadena JSON con el mensaje de error. Por ejemplo:

Por cierto, Postman te permite generar el código para varios lenguajes. Por ejemplo en C# con RestSharp (no lo he probado, solo he copiado el código):

var client = new RestClient("http://localhost:8000/imprimir");
client.Timeout = -1;
var request = new RestRequest(Method.POST);
request.AddHeader("Content-Type", "application/json");
var body = @"{
" + "\n" +
@"    ""operaciones"": [
" + "\n" +
@"        {
" + "\n" +
@"            ""nombre"": ""Operación que no existe"",
" + "\n" +
@"            ""argumentos"": []
" + "\n" +
@"        },
" + "\n" +
@"        {
" + "\n" +
@"            ""nombre"": ""EstablecerAlineacion"",
" + "\n" +
@"            ""argumentos"": [
" + "\n" +
@"                1
" + "\n" +
@"            ]
" + "\n" +
@"        },
" + "\n" +
@"        {
" + "\n" +
@"            ""nombre"": ""EscribirTexto"",
" + "\n" +
@"            ""argumentos"": [
" + "\n" +
@"                ""Hola mundo desde Postman!\nUn barcode:\n""
" + "\n" +
@"            ]
" + "\n" +
@"        },
" + "\n" +
@"        {
" + "\n" +
@"            ""nombre"": ""ImprimirCodigoDeBarrasCode39"",
" + "\n" +
@"            ""argumentos"": [
" + "\n" +
@"                ""123"",
" + "\n" +
@"                true,
" + "\n" +
@"                true,
" + "\n" +
@"                100,
" + "\n" +
@"                320,
" + "\n" +
@"                0
" + "\n" +
@"            ]
" + "\n" +
@"        },
" + "\n" +
@"        {
" + "\n" +
@"            ""nombre"": ""Iniciar"",
" + "\n" +
@"            ""argumentos"": []
" + "\n" +
@"        },
" + "\n" +
@"        {
" + "\n" +
@"            ""nombre"": ""Feed"",
" + "\n" +
@"            ""argumentos"": [
" + "\n" +
@"                2
" + "\n" +
@"            ]
" + "\n" +
@"        }
" + "\n" +
@"    ],
" + "\n" +
@"    ""nombreImpresora"": ""PT210"",
" + "\n" +
@"    ""serial"": """"
" + "\n" +
@"}";
request.AddParameter("application/json", body,  ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
Console.WriteLine(response.Content);

Lo que yo recomiendo es que hagas una clase o librería y por cada invocación a una función agregues un argumento a la lista de operaciones. Por ejemplo en Python:

def __init__(self, ruta=URL_PLUGIN_POR_DEFECTO, serial=""):
    self.operaciones = []
    self.ruta = ruta
    self.serial = serial

def agregar_operacion(self, nombre, argumentos):
    self.operaciones.append({
        "nombre": nombre,
        "argumentos": argumentos,
    })
    
def CargarImagenLocalEImprimir(self, ruta: str, tamaño: float, maximoAncho: float):
    return self.agregar_operacion("CargarImagenLocalEImprimir", [ruta, tamaño, maximoAncho])
    

Si te fijas en el init inicializo una lista vacía.

Luego defino la función agregar_operacion en donde agrego el nombre y los argumentos a la lista y finalmente hasta abajo tenemos una función llamada CargarImagenLocalEImprimir que recibe los argumentos y los agrega a la lista.

Luego para enviarlos simplemente codifico esa lista como JSON y la envío con requests:

def imprimirEn(self, nombreImpresora):
    payload = {
        "operaciones": self.operaciones,
        "nombreImpresora": nombreImpresora,
        "serial": self.serial,
    }
    respuesta = requests.post(self.ruta+"/imprimir", json=payload)
    return respuesta.json()

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

Te recomiendo ver el código fuente del conector JavaScript, Python y Java para que veas cómo lo hago yo y puedas tomar ideas.

Vídeo de apoyo

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