Ein Inventarprogramm anbinden¶

tavletta token new inventory-tool --role print --printer it-cab \
    --tokens tokens.toml --printers printers.toml

TAVLETTA=https://labels.example.com/api/v1
TOKEN=tav_3f9c0a1b2c4d_Xq2…

curl -H "Authorization: Bearer $TOKEN" "$TAVLETTA/labels/asset-tag"

curl -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
     -d '{"label": "asset-tag", "printer": "it-cab", "data_rows": [{"AssetNumber": "100001"}]}' \
     -o preview.png "$TAVLETTA/preview"

curl -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
     -d '{"label": "asset-tag", "printer": "it-cab", "data_rows": [{"AssetNumber": "100001"}], "wait": 30}' \
     "$TAVLETTA/print"

curl -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
     -d '{"label": "asset-tag", "printer": "it-cab", "wait": 60,
          "data_rows": [{"AssetNumber": "100001"}, {"AssetNumber": "100002"},
                        {"AssetNumber": "100003"}, {"AssetNumber": "100020"}]}' \
     "$TAVLETTA/print"

curl -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
     -d '{"label": "asset-tag-counter", "printer": "it-cab",
          "counter_start": 100001, "copies": 20, "no_save_counter": true}' \
     "$TAVLETTA/print"

curl -H "Authorization: Bearer $TOKEN" "$TAVLETTA/jobs/$JOB"

{"state": "failed", "printed": 13, "total": 20, "rows_printed": 13,
 "error": {"code": "printer_out_of_labels",
           "message": "… Printing stopped at row 14. To continue, print again from row 14."}}

curl -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' \
     -d '{"label": "asset-tag", "printer": "it-cab", "rows": "14-20",
          "data_rows": [{"AssetNumber": "100001"}, {"AssetNumber": "100020"}]}' \
     "$TAVLETTA/print"

curl -X DELETE -H "Authorization: Bearer $TOKEN" "$TAVLETTA/jobs/$JOB"

import os
import time

import requests

BASE = os.environ.get("TAVLETTA", "https://labels.example.com/api/v1")
TOKEN = os.environ["TAVLETTA_TOKEN"]  # from the secret store, never in the code
FINAL = {"done", "failed", "canceled"}


class LabelError(Exception):
    def __init__(self, status, code, message):
        super().__init__("%s %s: %s" % (status, code, message))
        self.status, self.code = status, code


session = requests.Session()
session.headers.update({"Authorization": "Bearer " + TOKEN, "Accept-Language": "de-CH"})


def call(method, path, **kwargs):
    response = session.request(method, BASE + path, timeout=330, **kwargs)
    if response.status_code >= 400:
        try:
            error = response.json()["error"]
        except (ValueError, KeyError):  # not from Tavletta, e.g. the proxy
            error = {"code": "http_%d" % response.status_code, "message": response.text}
        raise LabelError(response.status_code, error["code"], error["message"])
    return response


def print_assets(numbers, printer="it-cab", rows=None):
    """One label per asset number, in one job; returns the finished job."""
    body = {
        "label": "asset-tag",
        "printer": printer,
        "data_rows": [{"AssetNumber": str(n)} for n in numbers],
        "wait": 30,
    }
    if rows:
        body["rows"] = rows  # e.g. "14-20": only these rows
    for attempt in range(5):
        try:
            job = call("POST", "/print", json=body).json()
            break
        except LabelError as e:
            # refused before it was queued: nothing printed, safe to retry
            if e.code not in ("busy", "queue_full") or attempt == 4:
                raise
            time.sleep(2**attempt)
    while job["state"] not in FINAL:  # still printing after "wait"
        time.sleep(2)
        job = call("GET", "/jobs/" + job["id"]).json()
    return job


def preview(number, path="preview.png"):
    body = {"label": "asset-tag", "data_rows": [{"AssetNumber": str(number)}]}
    with open(path, "wb") as file:
        file.write(call("POST", "/preview", json=body).content)


if __name__ == "__main__":
    preview(100001)
    numbers = range(100001, 100021)  # 20 labels
    job = print_assets(numbers)
    if job["state"] == "failed":
        print("Stopped:", job["error"]["message"])
        # rows_printed rows are done: print the rest once the printer is fixed
        rest = "%d-%d" % (job["rows_printed"] + 1, len(numbers))
        print("To continue:", rest)
    else:
        print(job["state"], job["printed"], "of", job["total"])

using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using System.Text;
using System.Text.Json;
using System.Text.Json.Serialization;

var baseUrl = Environment.GetEnvironmentVariable("TAVLETTA") ?? "https://labels.example.com/api/v1";
var token = Environment.GetEnvironmentVariable("TAVLETTA_TOKEN")!; // from the secret store

using var http = new HttpClient { BaseAddress = new Uri(baseUrl.TrimEnd('/') + "/"), Timeout = TimeSpan.FromSeconds(330) };
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
http.DefaultRequestHeaders.AcceptLanguage.ParseAdd("de-CH");
var labels = new LabelClient(http);

var numbers = Enumerable.Range(100001, 20).Select(n => n.ToString()).ToList();
var job = await labels.PrintAssetsAsync(numbers, "it-cab");
Console.WriteLine(job.State == "failed"
    ? $"Stopped: {job.Error?.Message} To continue: rows {job.RowsPrinted + 1}-{numbers.Count}"
    : $"{job.State}: {job.Printed} of {job.Total}");

public record ApiError(string Code, string Message);
public record ErrorBody(ApiError Error);
public record Job(
    string Id, string State, int Printed, int Total,
    [property: JsonPropertyName("rows_printed")] int RowsPrinted, ApiError? Error);

public class LabelException(HttpStatusCode status, string code, string message) : Exception(message)
{
    public HttpStatusCode Status { get; } = status;
    public string Code { get; } = code;
}

public class LabelClient(HttpClient http)
{
    static readonly JsonSerializerOptions Json = new(JsonSerializerDefaults.Web);

    public async Task<Job> PrintAssetsAsync(IList<string> assetNumbers, string printer, string? rows = null)
    {
        var body = new Dictionary<string, object>
        {
            ["label"] = "asset-tag",
            ["printer"] = printer,
            ["data_rows"] = assetNumbers.Select(n => new Dictionary<string, string> { ["AssetNumber"] = n }),
            ["wait"] = 30,
        };
        if (rows != null) body["rows"] = rows; // e.g. "14-20"
        Job job;
        for (var attempt = 0; ; attempt++)
        {
            try { job = await SendAsync<Job>(HttpMethod.Post, "print", body); break; }
            catch (LabelException e) when (e.Code is "busy" or "queue_full" && attempt < 4)
            {
                await Task.Delay(TimeSpan.FromSeconds(Math.Pow(2, attempt))); // nothing was printed
            }
        }
        while (job.State is "queued" or "waiting" or "printing")
        {
            await Task.Delay(2000);
            job = await SendAsync<Job>(HttpMethod.Get, $"jobs/{job.Id}");
        }
        return job;
    }

    public Task<Job> CancelAsync(string jobId) => SendAsync<Job>(HttpMethod.Delete, $"jobs/{jobId}");

    async Task<T> SendAsync<T>(HttpMethod method, string path, object? body = null)
    {
        using var request = new HttpRequestMessage(method, path);
        // as a string: the server needs a Content-Length (JsonContent would send it chunked)
        if (body != null)
            request.Content = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
        using var response = await http.SendAsync(request);
        if (!response.IsSuccessStatusCode)
        {
            ErrorBody? error = null;
            try { error = await response.Content.ReadFromJsonAsync<ErrorBody>(Json); } catch (JsonException) { }
            throw new LabelException(response.StatusCode,
                error?.Error.Code ?? $"http_{(int)response.StatusCode}",
                error?.Error.Message ?? response.ReasonPhrase ?? "");
        }
        return (await response.Content.ReadFromJsonAsync<T>(Json))!;
    }
}