Order with an Assembly Line

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 CustomerId = "100198";
const string SalesLocId = "10";
const string SourceLocId = "10";
const string ShipToId = "200";
const string ContactId = "300";
const string OrderDate = "2030-01-05";
const string RequestedDate = "2030-01-06";
const string PoNo = "PO-TEST-001";
const string Taker = "JSMITH";              // else the order is taken by the API user
const string AssemblyItemId = "WIDGET-001"; // the assembly item to explode
const string UnitQuantity = "5";
// ---------------------------------------------------------------------------

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 iapi = $"{uiServer}/api/ui/interactive";

// Status is an integer (ResultStatus enum: 0 None, 1 Success, 2 Failure,
// 3 Blocked) but may appear as a string in some contexts -- handle both.
static bool IsBlocked(JsonElement r) =>
    r.TryGetProperty("Status", out var s) && StatusText(s) is "3" or "Blocked";

static string? StatusText(JsonElement s) =>
    s.ValueKind == JsonValueKind.String ? s.GetString() : s.ToString();

// Window IDs of popups opened by the last action.
// Events[].Data is a key-value list: [{"Key": "windowid", "Value": "..."}].
static List<string> PopupIds(JsonElement r)
{
    var ids = new List<string>();
    if (!r.TryGetProperty("Events", out var events)) return ids;
    foreach (var e in events.EnumerateArray())
    {
        if (e.GetProperty("Name").GetString() != "windowopened") continue;
        foreach (var kv in e.GetProperty("Data").EnumerateArray())
        {
            if (kv.GetProperty("Key").GetString() == "windowid")
            {
                ids.Add(kv.GetProperty("Value").GetString()!);
            }
        }
    }
    return ids;
}

// Answer every popup the last action opened; button null => first proceed button.
async Task<JsonElement> AnswerResponseWindowsAsync(JsonElement result, string? button = null)
{
    foreach (var popupId in PopupIds(result))
    {
        // Tools endpoint takes ?windowId=, NOT ?id=
        using var toolsResp = await client.GetAsync($"{iapi}/v2/tools?windowId={popupId}");
        toolsResp.EnsureSuccessStatusCode();
        using var tools = JsonDocument.Parse(await toolsResp.Content.ReadAsStringAsync());
        var available = tools.RootElement.EnumerateArray()
            .Select(t => t.TryGetProperty("Name", out var n)
                ? n.GetString()
                : t.GetProperty("ToolName").GetString())
            .ToList();
        var pick = button
            ?? new[] { "cb_ok", "cb_1", "cb_yes" }.FirstOrDefault(available.Contains)
            ?? throw new InvalidOperationException(
                $"Popup {popupId}: buttons [{string.Join(", ", available)}]");
        var clickBody = JsonSerializer.Serialize(new { WindowId = popupId, ToolName = pick });
        using var clickResp = await client.PostAsync($"{iapi}/v2/tools",
            new StringContent(clickBody, Encoding.UTF8, "application/json"));
        clickResp.EnsureSuccessStatusCode();
        using var clicked = JsonDocument.Parse(await clickResp.Content.ReadAsStringAsync());
        result = clicked.RootElement.Clone();
    }
    return result;
}

// Change one field; answer the popup it triggers (if any) with `answer`.
async Task<JsonElement> ChangeAsync(string windowId, string tab, string dw,
    string field, string value, string? answer = null)
{
    var body = JsonSerializer.Serialize(new
    {
        WindowId = windowId,
        List = new[]
        {
            new
            {
                TabName = tab,
                DatawindowName = dw,   // required on 25.2+
                FieldName = field,
                Value = value,
            },
        },
    });
    using var resp = await client.PutAsync($"{iapi}/v2/change",
        new StringContent(body, Encoding.UTF8, "application/json"));
    resp.EnsureSuccessStatusCode();
    using var parsed = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
    var result = parsed.RootElement.Clone();
    if (result.TryGetProperty("Status", out var status) &&
        StatusText(status) is "2" or "Failure")
    {
        throw new InvalidOperationException($"{field}: {result.GetProperty("Messages")}");
    }
    return IsBlocked(result) ? await AnswerResponseWindowsAsync(result, answer) : result;
}

// 1. Session with response-window handling ON
using (var sessResp = await client.PostAsync($"{iapi}/sessions",
    new StringContent(
        JsonSerializer.Serialize(new { ResponseWindowHandlingEnabled = true }),
        Encoding.UTF8, "application/json")))
{
    sessResp.EnsureSuccessStatusCode();
}

// 2. Open the Order window
string windowId;
using (var winResp = await client.PostAsync($"{iapi}/v2/window",
    new StringContent(JsonSerializer.Serialize(new { ServiceName = "Order" }),
        Encoding.UTF8, "application/json")))
{
    winResp.EnsureSuccessStatusCode();
    using var win = JsonDocument.Parse(await winResp.Content.ReadAsStringAsync());
    windowId = win.RootElement.GetProperty("WindowId").GetString()!;
}

string? orderNo = null;
try
{
    // 3. Header -- TABPAGE_1 / datawindow "order". quote OFF = real order.
    await ChangeAsync(windowId, "TABPAGE_1", "order", "quote", "OFF");
    await ChangeAsync(windowId, "TABPAGE_1", "order", "sales_loc_id", SalesLocId);
    await ChangeAsync(windowId, "TABPAGE_1", "order", "source_loc_id", SourceLocId);
    await ChangeAsync(windowId, "TABPAGE_1", "order", "customer_id", CustomerId);
    await ChangeAsync(windowId, "TABPAGE_1", "order", "ship_to_id", ShipToId);
    await ChangeAsync(windowId, "TABPAGE_1", "order", "contact_id", ContactId);
    // Dates fire the w_response_common date-cascade prompt even on a NEW order
    await ChangeAsync(windowId, "TABPAGE_1", "order", "order_date", OrderDate, "cb_ok");
    await ChangeAsync(windowId, "TABPAGE_1", "order", "requested_date", RequestedDate, "cb_ok");
    await ChangeAsync(windowId, "TABPAGE_1", "order", "po_no", PoNo);
    await ChangeAsync(windowId, "TABPAGE_1", "order", "taker", Taker);

    // 4. Lines tab
    await SwitchTabAsync(client, iapi, windowId, "TP_ITEMS");

    // 5. Item on the EXISTING items row; assembly prompt: cb_1 = Yes (explode)
    await ChangeAsync(windowId, "TP_ITEMS", "items", "oe_order_item_id",
        AssemblyItemId, "cb_1");
    // 6. Quantity
    await ChangeAsync(windowId, "TP_ITEMS", "items", "unit_quantity", UnitQuantity);

    // 7. Save -- v2 body is the bare window-ID JSON string (an object => 422)
    JsonElement result;
    using (var saveResp = await client.PutAsync($"{iapi}/v2/data",
        new StringContent($"\"{windowId}\"", Encoding.UTF8, "application/json")))
    {
        saveResp.EnsureSuccessStatusCode();
        using var saved = JsonDocument.Parse(await saveResp.Content.ReadAsStringAsync());
        result = saved.RootElement.Clone();
    }
    while (IsBlocked(result))  // follow-on prompts: answer with proceed button
    {
        result = await AnswerResponseWindowsAsync(result);
    }
    if (result.TryGetProperty("Status", out var saveStatus) &&
        StatusText(saveStatus) is "2" or "Failure")
    {
        throw new InvalidOperationException($"Save failed: {result.GetProperty("Messages")}");
    }

    // 8. Read order_no back -- /v2/data returns the ACTIVE surface, so
    //    switch back to the header tab first.
    await SwitchTabAsync(client, iapi, windowId, "TABPAGE_1");
    using var dataResp = await client.GetAsync($"{iapi}/v2/data?id={windowId}");
    dataResp.EnsureSuccessStatusCode();
    using var data = JsonDocument.Parse(await dataResp.Content.ReadAsStringAsync());
    foreach (var dw in data.RootElement.EnumerateArray())
    {
        if (dw.GetProperty("Name").GetString() != "order") continue;
        var columns = dw.GetProperty("Columns").EnumerateArray()
            .Select(c => c.GetString()).ToList();
        var activeRow = dw.TryGetProperty("ActiveRow", out var a) ? a.GetInt32() : 0;
        var row = dw.GetProperty("Data")[activeRow];
        orderNo = row[columns.IndexOf("order_no")].ToString();
        Console.WriteLine($"Created order_no: {orderNo}");
    }
}
finally
{
    // 9. Clean up (window uses ?id=; sessions endpoint takes no parameter)
    await client.DeleteAsync($"{iapi}/v2/window?id={windowId}");
    await client.DeleteAsync($"{iapi}/sessions");
}

// 10. Verify via OData (mirrors the Verify section): assembly codes on the
//     lines, and the production-order link for the assembly line.
foreach (var line in await ODataAsync(client, "oe_line", $"order_no eq '{orderNo}'"))
{
    // assembly: B = kit parent, N = component, P = production-order line,
    // S = build-to-stock allocation
    var assembly = line.GetProperty("assembly").GetString();
    Console.WriteLine($"Line {line.GetProperty("line_no")}: assembly={assembly}");
    if (assembly != "P") continue;
    var links = await ODataAsync(client, "prod_order_line_link",
        $"transaction_uid eq {line.GetProperty("oe_line_uid")} and trans_type eq 'O'");
    Console.WriteLine($"  prod_order_line_link: {(links.Count > 0 ? "present" : "MISSING")}");
}

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

static async Task SwitchTabAsync(HttpClient client, string iapi, string windowId, string page)
{
    var body = JsonSerializer.Serialize(new { WindowId = windowId, PageName = page });
    using var resp = await client.PutAsync($"{iapi}/v2/tab",
        new StringContent(body, Encoding.UTF8, "application/json"));
    resp.EnsureSuccessStatusCode();
}

static async Task<List<JsonElement>> ODataAsync(HttpClient client, string table, string filter)
{
    using var response = await client.GetAsync(
        $"{BaseUrl}/odataservice/odata/table/{table}?$filter=" + Uri.EscapeDataString(filter));
    response.EnsureSuccessStatusCode();
    using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
    return doc.RootElement.GetProperty("value").EnumerateArray()
        .Select(x => x.Clone()).ToList();
}

// 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;
}