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.example.com";   // your P21 server
const string Username = "apiuser";
const string Password = "your-password";
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 = "New",
            DataElements = new object[]
            {
                new
                {
                    Keys = Array.Empty<string>(),   // always empty for reports
                    Type = "Form",
                    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 before = await ReadTicketsAsync(client);
SaveDocuments(await RunReportAsync(client, uiServer, payload), "pick_ticket");

// --- Read-back: m_picktickets CREATED a ticket row; find it over OData. ---
// The FileName number (PPT<nnn>) is a document counter, not the ticket
// number, so compare the order's tickets before and after the run.
var after = await ReadTicketsAsync(client);
var created = after.Keys.Except(before.Keys).OrderBy(n => n).ToList();
if (created.Count == 0)
    throw new InvalidOperationException($"No new pick ticket on production order {ProdOrder}");
foreach (var number in created)
{
    var ticket = after[number];
    // row_status_flag: 702 = Open, 1962 = Confirmed, 1268 = Completed
    Console.WriteLine($"New ticket {number} at location {ticket.GetProperty("location_id")}: " +
                      $"status {ticket.GetProperty("row_status_flag")}");
}

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

// The order's production pick tickets, read over OData, keyed by ticket number.
static async Task<Dictionary<long, JsonElement>> ReadTicketsAsync(HttpClient client)
{
    var filter = Uri.EscapeDataString($"prod_order_number eq {ProdOrder}");
    using var response = await client.GetAsync(
        $"{BaseUrl}/odataservice/odata/table/prod_pick_ticket_hdr?$filter={filter}" +
        "&$select=prod_pick_ticket_number,location_id,row_status_flag");
    response.EnsureSuccessStatusCode();
    using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
    return doc.RootElement.GetProperty("value").EnumerateArray().ToDictionary(
        row => row.GetProperty("prod_pick_ticket_number").GetInt64(), row => row.Clone());
}

// 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";
        // <nnn> is a document counter, not the pick-ticket number
        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;
}

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

// Usage: dotnet run -- [ORDER_NO] [LOCATION_ID]

// ---- EDIT THESE -----------------------------------------------------------
const string BaseUrl = "https://play.example.com";   // your P21 server
const string Username = "apiuser";
const string Password = "your-password";
const string CompanyId = "ACME";                // company the order belongs to
const string DefaultOrderNo = "1001234";        // sales order number (argument 1 overrides)
const string DefaultLocationId = "10";          // location to pick from (argument 2 overrides)
const string DateFrom = "1900-01-01T00:00:00";  // every date range is sent this wide --
const string DateTo = "2099-12-31T23:59:59";    // the server defaults can end in the past
const string OutputDir = ".";                   // where the .pdf file is written
// ---------------------------------------------------------------------------

var orderNo = args.Length > 0 ? args[0] : DefaultOrderNo;
var locationId = args.Length > 1 ? args[1] : DefaultLocationId;
// Both go into an OData filter, so accept digits only.
if (orderNo.Length == 0 || !orderNo.All(char.IsAsciiDigit) ||
    locationId.Length == 0 || !locationId.All(char.IsAsciiDigit))
    throw new ArgumentException("Order number and location ID must be numbers");

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(5) };
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 = false,   // labels; true with "S" or "O" is an empty 500
    Transactions = new object[]
    {
        new
        {
            Status = "New",
            DataElements = new object[]
            {
                new
                {
                    Keys = Array.Empty<string>(),   // always empty for reports
                    Type = "Form",
                    Name = "TABPAGE_1.tp_1_dw_1",
                    Rows = new object[]
                    {
                        new
                        {
                            Edits = new[]
                            {
                                new { Name = "company_id", Value = CompanyId },
                                new { Name = "create_pick_ticket_type", Value = "Sales Order" },
                                // order range: from and to are the same order
                                new { Name = "order_no", Value = orderNo },
                                new { Name = "order_number", Value = orderNo },
                                new { Name = "location_id", Value = locationId },
                                // All three date ranges, sent wide. Any range you omit
                                // takes the server default, which can end on a past date
                                // and drop current orders: HTTP 200, empty array, no ticket.
                                new { Name = "dt_beg_date2", Value = DateFrom },   // SO required date
                                new { Name = "dt_end_date2", Value = DateTo },
                                new { Name = "beg_order_date", Value = DateFrom },
                                new { Name = "end_order_date", Value = DateTo },
                                new { Name = "beg_pick_date", Value = DateFrom },
                                new { Name = "end_pick_date", Value = DateTo },
                                new { Name = "print_qty", Value = "1" },
                            },
                        },
                    },
                },
            },
        },
    },
};

var before = await ReadTicketsAsync(client, orderNo);
var documents = await RunReportAsync(client, uiServer, payload);
var saved = SaveDocuments(documents, orderNo);

// --- Read-back: m_picktickets CREATED an oe_pick_ticket row. ---
// Read it even when no document came back: a retried 5xx can leave a ticket
// created by the first attempt and an empty array from the retry.
var after = await ReadTicketsAsync(client, orderNo);
var created = after.Keys.Except(before.Keys).OrderBy(n => n).ToList();
if (created.Count == 0 && documents.Count > 0)
{
    throw new InvalidOperationException(
        $"{documents.Count} document(s) returned but no new oe_pick_ticket row on order {orderNo}");
}
if (created.Count == 0)
{
    // HTTP 200 with [] means the criteria matched nothing printable.
    throw new InvalidOperationException(
        $"No pick ticket generated for order {orderNo} at location {locationId}. Check: the " +
        "order has allocated quantity at that location not already on a ticket; every " +
        "kit/assembly parent line can fully allocate; the order and required dates fall " +
        "inside the date ranges sent.");
}
foreach (var number in created)
{
    var ticket = after[number];
    Console.WriteLine($"New pick ticket {number} on order {ticket.GetProperty("order_no")} " +
                      $"at location {ticket.GetProperty("location_id")}, " +
                      $"printed {ticket.GetProperty("print_date")}");
}
if (saved == 0)
{
    throw new InvalidOperationException(
        "The ticket exists but no PDF was saved; reprint it with m_reprintpicktickets.");
}

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

// The order's pick tickets, read over OData, keyed by ticket number.
static async Task<Dictionary<long, JsonElement>> ReadTicketsAsync(HttpClient client, string orderNo)
{
    var filter = Uri.EscapeDataString($"order_no eq '{orderNo}'");
    using var response = await client.GetAsync(
        $"{BaseUrl}/odataservice/odata/table/oe_pick_ticket?$filter={filter}" +
        "&$select=pick_ticket_no,order_no,location_id,print_date");
    response.EnsureSuccessStatusCode();
    using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
    return doc.RootElement.GetProperty("value").EnumerateArray().ToDictionary(
        row => row.GetProperty("pick_ticket_no").GetInt64(), row => row.Clone());
}

// POST a report payload and return its document array (possibly empty).
// Retries an empty 5xx, which the report engine emits now and then and which
// clears on the next try. This retry is not free of side effects here:
// m_picktickets creates the ticket, so a 5xx after the ticket was created
// makes the retry return [] -- the caller reads oe_pick_ticket before it
// reports a failure. Do not retry an empty array itself: it is a
// deterministic "nothing matched" (see the eligibility traps).
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: the ErrorType /
        // ErrorMessage envelope can arrive on a 200 as well as a 4xx/5xx.
        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))
            {
                throw new InvalidOperationException($"{obj.GetProperty("ErrorType")}: {err}");
            }

            if (response.IsSuccessStatusCode)
            {
                if (root is not { ValueKind: JsonValueKind.Array } arr)
                    throw new InvalidOperationException($"Unexpected response: {bodyText}");
                return arr.EnumerateArray().Select(x => x.Clone()).ToList();
            }

            // Only a 5xx is worth retrying.
            if ((int)response.StatusCode < 500 || attempt >= attempts)
            {
                var hint = (int)response.StatusCode >= 500
                    ? " -- an attempt may still have created the ticket; check oe_pick_ticket before rerunning."
                    : "";
                throw new InvalidOperationException(
                    $"HTTP {(int)response.StatusCode} after {attempt} attempt(s). " +
                    $"Body: {(string.IsNullOrEmpty(bodyText) ? "(empty)" : bodyText)}{hint}");
            }
        }
        await Task.Delay(TimeSpan.FromSeconds(0.5 * attempt));
    }
}

// Write every returned base64 document to OutputDir; return how many were saved.
static int SaveDocuments(List<JsonElement> documents, string orderNo)
{
    var saved = 0;
    foreach (var doc in documents)
    {
        var hasStatus = doc.TryGetProperty("ResponseStatus", out var responseStatus) &&
                        responseStatus.ValueKind == JsonValueKind.Object;
        var status = hasStatus && responseStatus.TryGetProperty("StatusCode", out var s)
            ? s.GetString() : null;
        var documentData = doc.TryGetProperty("DocumentData", out var d) ? d.GetString() : null;
        if (status != "Success" || string.IsNullOrEmpty(documentData))
        {
            Console.WriteLine($"Document failed: {(hasStatus ? responseStatus.ToString() : doc.ToString())}");
            continue;
        }
        var pdfBytes = Convert.FromBase64String(documentData);
        // FileName is like "PT<nnn> PICK_TICKET.pdf"; <nnn> is a document
        // counter, not the pick-ticket number
        var filename = doc.TryGetProperty("FileName", out var f) && !string.IsNullOrEmpty(f.GetString())
            ? f.GetString()! : $"pick_ticket_{orderNo}.pdf";
        var path = Path.Combine(OutputDir, Path.GetFileName(filename));
        File.WriteAllBytes(path, pdfBytes);
        Console.WriteLine($"Saved {path} ({pdfBytes.Length} bytes, starts with " +
                          $"{Encoding.ASCII.GetString(pdfBytes, 0, 4)})");
        saved++;
    }
    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;
}