Generate Pick Ticket and PO PDFs

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

// ---- EDIT THESE -----------------------------------------------------------
const string BaseUrl = "https://play.p21server.com";   // your P21 server
const string Username = "apiuser";
const string Password = "your-password";
const string CompanyId = "ACME";
const string ProdOrder = "1000123";     // production order number (beg = end)
const string LocationId = "10";         // location the components pick from
const string OutputDir = ".";           // where the .pdf files are written
// ---------------------------------------------------------------------------

var handler = new HttpClientHandler
{
    // Test tenants often present a self-signed cert. Delete this line in production.
    ServerCertificateCustomValidationCallback =
        HttpClientHandler.DangerousAcceptAnyServerCertificateValidator,
};
using var client = new HttpClient(handler) { Timeout = TimeSpan.FromMinutes(2) };
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

var token = await GetTokenAsync(client);
var uiServer = await GetUiServerAsync(client, token);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);

var payload = new
{
    Name = "m_picktickets",
    UseCodeValues = true,   // required here -- false returns HTTP 500
    Transactions = new object[]
    {
        new
        {
            Status = 0,     // numeric 0 for report payloads
            DataElements = new object[]
            {
                new
                {
                    Keys = Array.Empty<string>(),   // always empty for reports
                    Type = 0,                       // numeric 0 for report payloads
                    Name = "TABPAGE_1.tp_1_dw_1",
                    Rows = new object[]
                    {
                        new
                        {
                            Edits = new[]
                            {
                                // code "P" = Production Order (label is rejected)
                                new { Name = "create_pick_ticket_type", Value = "P" },
                                new { Name = "beg_prod_order", Value = ProdOrder },
                                new { Name = "end_prod_order", Value = ProdOrder },
                                // location whose inventory the components pick from
                                new { Name = "location_id", Value = LocationId },
                            },
                        },
                    },
                },
            },
        },
    },
};

var saved = SaveDocuments(await RunReportAsync(client, uiServer, payload), "pick_ticket");

// --- Read-back: m_picktickets CREATED a ticket row, so reprint it. ---
// A second PDF proves the pick-ticket record exists in P21.
foreach (var filename in saved)
{
    var match = System.Text.RegularExpressions.Regex.Match(filename, @"^PPT(\d+)");
    if (!match.Success) continue;
    var ticketNo = match.Groups[1].Value;
    var reprint = new
    {
        Name = "m_reprintpicktickets",
        // if this errors on correct criteria, retry with true + code values
        UseCodeValues = false,
        Transactions = new object[]
        {
            new
            {
                Status = 0,
                DataElements = new object[]
                {
                    new
                    {
                        Keys = Array.Empty<string>(),
                        Type = 0,
                        Name = "TABPAGE_1.tp_1_dw_1",
                        Rows = new object[]
                        {
                            new
                            {
                                Edits = new[]
                                {
                                    new { Name = "company_id", Value = CompanyId },
                                    new { Name = "location_id", Value = LocationId },
                                    new { Name = "print_qty", Value = "1" },
                                    new { Name = "beg_prod_pick_ticket_no", Value = ticketNo },
                                    new { Name = "end_prod_pick_ticket_no", Value = ticketNo },
                                },
                            },
                        },
                    },
                },
            },
        },
    };
    Console.WriteLine($"Reprinting ticket {ticketNo} to prove the record landed:");
    SaveDocuments(await RunReportAsync(client, uiServer, reprint), $"reprint_{ticketNo}");
}

// --- helpers ---------------------------------------------------------------

// POST a report payload and return its document array.
//
// Retries transient faults: the report engine emits occasional empty 5xx
// responses that clear on the next try (in production, 3 empty 500s and one
// dropped connection against 154 successes in an afternoon). Generating a
// document is an idempotent read, so a retry costs latency, not correctness.
static async Task<List<JsonElement>> RunReportAsync(
    HttpClient client, string uiServer, object payload, int attempts = 3)
{
    var body = JsonSerializer.Serialize(payload);
    for (var attempt = 1; ; attempt++)
    {
        using var response = await client.PostAsync(
            $"{uiServer}/api/v2/process/pdfreport",
            new StringContent(body, Encoding.UTF8, "application/json"));
        var bodyText = await response.Content.ReadAsStringAsync();

        // Parse the body BEFORE looking at the status code. This endpoint
        // returns P21's ErrorType/ErrorMessage envelope -- not the
        // Summary/Messages shape of /transaction -- and that envelope can
        // arrive on a 200 as well as a 4xx/5xx. Branching on the status first
        // throws away the only message that explains the failure.
        JsonDocument? parsed = null;
        try { parsed = JsonDocument.Parse(bodyText); }
        catch (JsonException) { /* empty or non-JSON body */ }

        using (parsed)
        {
            var root = parsed?.RootElement;
            if (root is { ValueKind: JsonValueKind.Object } obj &&
                obj.TryGetProperty("ErrorMessage", out var err))
            {
                // A real, explained rejection ("No records to print for this
                // range.") -- retrying will not change it.
                throw new InvalidOperationException($"{obj.GetProperty("ErrorType")}: {err}");
            }

            if (response.IsSuccessStatusCode)
            {
                // Success is a JSON ARRAY -- even for a single document
                if (root is not { ValueKind: JsonValueKind.Array } arr || arr.GetArrayLength() == 0)
                    throw new InvalidOperationException($"No documents returned: {bodyText}");
                return arr.EnumerateArray().Select(x => x.Clone()).ToList();
            }

            if (attempt >= attempts)
            {
                // An empty 5xx has several unrelated causes: a transient engine
                // fault (retried above), criteria that match nothing (e.g. a
                // wrong company_id), or a record that is not printable.
                throw new InvalidOperationException(
                    $"HTTP {(int)response.StatusCode} after {attempts} attempts. " +
                    $"Body: {(string.IsNullOrEmpty(bodyText) ? "(empty)" : bodyText)}");
            }
        }
        await Task.Delay(TimeSpan.FromSeconds(0.5 * attempt));
    }
}

// Write every returned base64 document to OutputDir; return the file names.
static List<string> SaveDocuments(List<JsonElement> documents, string prefix)
{
    var saved = new List<string>();
    foreach (var doc in documents)
    {
        var responseStatus = doc.GetProperty("ResponseStatus");
        var status = responseStatus.GetProperty("StatusCode").GetString();
        var documentData = doc.TryGetProperty("DocumentData", out var d) ? d.GetString() : null;
        if (status != "Success" || string.IsNullOrEmpty(documentData))
        {
            var message = responseStatus.TryGetProperty("Message", out var m)
                ? m.GetString() : "Unknown error";
            Console.WriteLine($"Document failed: {message}");
            continue;
        }
        var pdfBytes = Convert.FromBase64String(documentData);
        // FileName includes .pdf, e.g. "PPT<nnn> PRODUCTION_PICK_TICKET.pdf"
        var filename = doc.TryGetProperty("FileName", out var f)
            ? f.GetString()! : $"{prefix}.pdf";
        var path = Path.Combine(OutputDir, filename);
        File.WriteAllBytes(path, pdfBytes);
        // A real PDF starts with the %PDF magic bytes
        Console.WriteLine($"Saved {path} ({pdfBytes.Length} bytes, starts with " +
                          $"{Encoding.ASCII.GetString(pdfBytes, 0, 4)})");
        saved.Add(filename);
    }
    return saved;
}

// v2 token endpoint — credentials go in the body, never in headers.
static async Task<string> GetTokenAsync(HttpClient client)
{
    var payload = JsonSerializer.Serialize(new { username = Username, password = Password });
    var response = await client.PostAsync(
        $"{BaseUrl}/api/security/token/v2",
        new StringContent(payload, Encoding.UTF8, "application/json"));
    response.EnsureSuccessStatusCode();
    return ReadField(await response.Content.ReadAsStringAsync(), "AccessToken");
}

// Transaction and Interactive calls go to the UI server, not BaseUrl.
static async Task<string> GetUiServerAsync(HttpClient client, string token)
{
    using var request = new HttpRequestMessage(
        HttpMethod.Get, $"{BaseUrl}/api/ui/router/v1/?urlType=external");
    request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
    var response = await client.SendAsync(request);
    response.EnsureSuccessStatusCode();
    return ReadField(await response.Content.ReadAsStringAsync(), "Url").TrimEnd('/');
}

// Some middleware answers these two endpoints in XML even when asked for JSON.
static string ReadField(string payload, string field)
{
    try
    {
        var value = JsonDocument.Parse(payload).RootElement.GetProperty(field).GetString();
        if (!string.IsNullOrEmpty(value)) return value;
    }
    catch (Exception ex) when (ex is JsonException or KeyNotFoundException) { }

    var match = System.Text.RegularExpressions.Regex.Match(payload, $"<{field}>([^<]+)</{field}>");
    if (!match.Success)
        throw new InvalidOperationException(
            $"No {field} in response: {payload[..Math.Min(200, payload.Length)]}");
    return match.Groups[1].Value;
}