Change a Saved Order Line to Direct Ship

// Change a SAVED sales-order line to Direct Ship (disposition D), optionally creating its PO.
// Re-open the order in the Order window, make the line the active row of the `items` grid and
// change `disposition` to the CODE value "D" ("Direct Ship" is refused). `disposition` is
// disabled while the line holds allocated stock ("Column is disabled: disposition"), so an
// allocated line is released first with TP_EXTDINFO.extd_info.allocated_qty = 0.
//
//   dotnet run -- [ORDER_NO LINE_NO] [--execute] [--create-po] [--po-cost 8]
//
// Without --execute it makes the changes in the window and stops (dry run). --create-po also
// ticks the header's c_create_po, so the save opens the "Create RFQ/Purchase Orders" wizard;
// the program drives it (cb_next commits the PO, cb_finish closes it). That step needs a P21
// user with a Buyer ID.
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";                   // for --create-po: a P21 user with a Buyer ID
const string Password = "your-password";
string orderNo = "1001234";                          // the saved order
string lineNo = "1";                                 // the line to convert (the window's line number)
bool execute = false;                                // true saves; false is a dry run
bool createPo = false;                               // true also creates the direct-ship PO in the same save
string poCost = "";                                  // e.g. "8" -- the line's PO cost (flows to the PO line price)
// ---------------------------------------------------------------------------

const int Blocked = 3;                               // ResultStatus: a prompt or wizard is waiting
const string OrderColumns = "order_no,line_no,disposition,po_cost,qty_ordered,qty_allocated,qty_on_pick_tickets";

var rest = new List<string>();
for (var i = 0; i < args.Length; i++)
{
    if (args[i] == "--execute") execute = true;
    else if (args[i] == "--create-po") createPo = true;
    else if (args[i] == "--po-cost" && i + 1 < args.Length) poCost = args[++i];
    else rest.Add(args[i]);
}
if (rest.Count is not (0 or 2)) { Console.WriteLine("Pass both the order number and the line number, or neither to use the constants"); return; }
if (rest.Count == 2) { orderNo = rest[0]; lineNo = rest[1]; }
if (orderNo.Length == 0 || lineNo.Length == 0 || !orderNo.All(char.IsAsciiDigit) || !lineNo.All(char.IsAsciiDigit))
{ Console.WriteLine("The order and line numbers must be digits"); return; }   // they go into an OData filter

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(3) };
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";

Console.WriteLine("Before:");
var before = await ReadBackAsync();
if (Num(before, "qty_on_pick_tickets") > 0) { Console.WriteLine("The line is on a pick ticket -- reverse the pick ticket first"); return; }

await CallAsync(HttpMethod.Post, "/sessions/", "start session", new { ResponseWindowHandlingEnabled = true });
var window = "";
string? poNo = null;
try
{
    window = (await CallAsync(HttpMethod.Post, "/v2/window", "open Order", new { ServiceName = "Order" })).GetProperty("WindowId").GetString()!;
    await ChangeAsync(window, "TABPAGE_1", "order", "quote", "OFF");
    await ChangeAsync(window, "TABPAGE_1", "order", "order_no", orderNo);
    await TabAsync(window, "TP_ITEMS");

    // The grid has no line_no column; the window's line number is user_line_no.
    var grid = await RowsAsync(window, "items");
    var found = grid.FindIndex(r => int.TryParse(Cell(r, "user_line_no").Split('.')[0], out var n) && n == int.Parse(lineNo));
    if (found < 0) { Console.WriteLine($"Line {lineNo} is not in the items grid"); return; }
    await CallAsync(HttpMethod.Put, "/v2/row", "select row", new { WindowId = window, DatawindowName = "items", Row = found + 1 });

    if (Num(before, "qty_allocated") > 0)
    {
        // Allocated stock locks `disposition`; releasing it resets disposition to B and enables the column.
        await TabAsync(window, "TP_EXTDINFO");
        await AnswerAsync(await ChangeAsync(window, "TP_EXTDINFO", "extd_info", "allocated_qty", "0"));
        Console.WriteLine($"  released allocation: {Cell((await ActiveRowAsync(window, "extd_info")), "allocated_qty")}");
        await TabAsync(window, "TP_ITEMS");
    }
    await AnswerAsync(await ChangeAsync(window, "TP_ITEMS", "items", "disposition", "D"));
    if (poCost.Length > 0) await AnswerAsync(await ChangeAsync(window, "TP_ITEMS", "items", "po_cost", poCost));
    var line = (await RowsAsync(window, "items"))[found];
    Console.WriteLine($"  in window: disposition={Cell(line, "disposition")} po_cost={Cell(line, "po_cost")}");
    if (createPo)
    {
        await TabAsync(window, "TABPAGE_1");
        await AnswerAsync(await ChangeAsync(window, "TABPAGE_1", "order", "c_create_po", "ON"));
    }
    if (!execute) { Console.WriteLine("Dry run: not saved (set execute = true or pass --execute)"); return; }
    poNo = await AnswerAsync(await CallAsync(HttpMethod.Put, "/v2/data", "save", window));
    Console.WriteLine("  saved");
}
finally
{
    if (window.Length > 0) await client.DeleteAsync($"{iapi}/v2/window?id={window}");
    await client.DeleteAsync($"{iapi}/sessions/");
}

Console.WriteLine("After:");
var after = await ReadBackAsync();
if (Cell(after, "disposition") != "D") { Console.WriteLine("disposition did not stick"); return; }
if (createPo && poNo is null) { Console.WriteLine("The wizard did not run -- no PO (does the user have a Buyer ID?)"); return; }
Console.WriteLine("OK");

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

// One Interactive call; refuses HTTP errors and Status 2 (failure). Status 3 is returned.
async Task<JsonElement> CallAsync(HttpMethod method, string path, string what, object? body = null)
{
    using var request = new HttpRequestMessage(method, $"{iapi}{path}");
    if (body is not null)
        request.Content = new StringContent(JsonSerializer.Serialize(body), Encoding.UTF8, "application/json");
    var response = await client.SendAsync(request);
    var text = await response.Content.ReadAsStringAsync();
    if ((int)response.StatusCode >= 400)
        throw new InvalidOperationException($"{what}: HTTP {(int)response.StatusCode} {text[..Math.Min(300, text.Length)]}");
    var answer = text.Length == 0 ? JsonDocument.Parse("{}").RootElement : JsonDocument.Parse(text).RootElement.Clone();
    if (answer.ValueKind == JsonValueKind.Object && answer.TryGetProperty("Status", out var s)
        && s.ValueKind == JsonValueKind.Number && s.GetInt32() == 2)
        throw new InvalidOperationException($"{what}: refused: {answer.GetProperty("Messages")}");
    return answer;
}

Task<JsonElement> ChangeAsync(string win, string tab, string dw, string field, string value) =>
    CallAsync(HttpMethod.Put, "/v2/change", $"change {field}", new
    {
        WindowId = win,
        List = new[] { new { TabName = tab, DatawindowName = dw, FieldName = field, Value = value } },
    });

Task<JsonElement> TabAsync(string win, string page) =>
    CallAsync(HttpMethod.Put, "/v2/tab", $"tab {page}", new { WindowId = win, PageName = page });

// Datawindows on the window's active surface, as column -> value maps per row.
async Task<List<Dictionary<string, string>>> RowsAsync(string win, string dwName)
{
    var data = await CallAsync(HttpMethod.Get, $"/v2/data?id={win}", "data");
    var rows = new List<Dictionary<string, string>>();
    foreach (var dw in data.EnumerateArray())
    {
        if (dw.GetProperty("Name").GetString() != dwName) continue;
        var columns = dw.GetProperty("Columns").EnumerateArray().Select(c => c.GetString()!).ToList();
        if (!dw.TryGetProperty("Data", out var rowData) || rowData.ValueKind != JsonValueKind.Array) continue;
        foreach (var row in rowData.EnumerateArray())
        {
            var cells = row.EnumerateArray().ToList();
            var map = new Dictionary<string, string>();
            for (var i = 0; i < columns.Count && i < cells.Count; i++)
                map[columns[i]] = cells[i].ValueKind == JsonValueKind.Null ? "" : cells[i].ToString();
            rows.Add(map);
        }
    }
    return rows;
}

// The active row of one datawindow (ActiveRow is 1-based).
async Task<Dictionary<string, string>> ActiveRowAsync(string win, string dwName)
{
    var data = await CallAsync(HttpMethod.Get, $"/v2/data?id={win}", "data");
    foreach (var dw in data.EnumerateArray())
    {
        if (dw.GetProperty("Name").GetString() != dwName) continue;
        var active = dw.TryGetProperty("ActiveRow", out var a) && a.ValueKind == JsonValueKind.Number ? Math.Max(a.GetInt32() - 1, 0) : 0;
        var rows = await RowsAsync(win, dwName);
        if (active < rows.Count) return rows[active];
    }
    return new Dictionary<string, string>();
}

// Answer whatever a change or save opened; return the PO number if the wizard ran.
// A "no PO Cost" or profit prompt (w_message) is answered Yes (cb_1). The Create PO wizard is
// recognised by its cb_finish button: cb_next COMMITS the PO, cb_finish closes it.
async Task<string?> AnswerAsync(JsonElement result)
{
    string? po = null;
    while (result.ValueKind == JsonValueKind.Object && result.TryGetProperty("Status", out var s)
           && s.ValueKind == JsonValueKind.Number && s.GetInt32() == Blocked)
    {
        var popup = result.GetProperty("Events").EnumerateArray()
            .Where(e => e.GetProperty("Name").GetString() == "windowopened")
            .SelectMany(e => e.GetProperty("Data").EnumerateArray())
            .First(kv => kv.GetProperty("Key").GetString() == "windowid").GetProperty("Value").GetString()!;
        var tools = (await CallAsync(HttpMethod.Get, $"/v2/tools?windowId={popup}", "tools"))
            .EnumerateArray().Select(t => t.GetProperty("ToolName").GetString()).ToList();   // includes the parent's ribbon
        var cls = (await CallAsync(HttpMethod.Get, $"/v2/window?id={popup}", "window")).GetProperty("Definition").GetProperty("Name").GetString();
        if (tools.Contains("cb_finish"))
        {
            foreach (var row in await RowsAsync(popup, "items"))
                Console.WriteLine($"  wizard: item={Cell(row, "item_id")} supplier={Cell(row, "supplier_id")} qty={Cell(row, "qty_to_purchase")}");
            await CallAsync(HttpMethod.Post, "/v2/tools", "tool cb_next", new { WindowId = popup, ToolName = "cb_next" });   // the PO is committed here
            po = Cell(await ActiveRowAsync(popup, "po_print"), "po_no");
            Console.WriteLine($"  wizard page 2: po_no={po}");
            result = await CallAsync(HttpMethod.Post, "/v2/tools", "tool cb_finish", new { WindowId = popup, ToolName = "cb_finish" });
        }
        else if (cls == "w_message" && tools.Contains("cb_1"))
        {
            Console.WriteLine("  prompt answered Yes (cb_1)");
            result = await CallAsync(HttpMethod.Post, "/v2/tools", "tool cb_1", new { WindowId = popup, ToolName = "cb_1" });
        }
        else throw new InvalidOperationException($"Unexpected response window: {string.Join(", ", tools)}");
    }
    return po;
}

// Print the line and any PO linked to it; return the line.
async Task<Dictionary<string, string>> ReadBackAsync()
{
    var lines = await ODataAsync("oe_line", $"order_no eq '{orderNo}' and line_no eq {lineNo}", OrderColumns);
    var line = lines[0].EnumerateObject().ToDictionary(p => p.Name, p => p.Value.ValueKind == JsonValueKind.Null ? "" : p.Value.ToString());
    Console.WriteLine("  oe_line: " + string.Join(", ", line.Select(p => $"{p.Key}={p.Value}")));
    foreach (var link in await ODataAsync("oe_line_po", $"order_number eq '{orderNo}' and line_number eq {lineNo}", ""))
    {
        var number = (int)link.GetProperty("po_no").GetDecimal();
        var po = (await ODataAsync("po_hdr", $"po_no eq {number}", "po_no,po_type,supplier_id,approved"))[0];
        Console.WriteLine($"  oe_line_po: po_no={number} connection_type={link.GetProperty("connection_type")} -> po_hdr type={po.GetProperty("po_type")} approved={po.GetProperty("approved")}");
    }
    return line;
}

// One OData table read.
async Task<List<JsonElement>> ODataAsync(string table, string filter, string select)
{
    var url = $"{BaseUrl}/odataservice/odata/table/{table}?$filter={Uri.EscapeDataString(filter)}";
    if (select.Length > 0) url += $"&$select={select}";
    var response = await client.GetAsync(url);
    response.EnsureSuccessStatusCode();
    return JsonDocument.Parse(await response.Content.ReadAsStringAsync())
        .RootElement.GetProperty("value").EnumerateArray().Select(e => e.Clone()).ToList();
}

static string Cell(Dictionary<string, string> row, string column) => row.TryGetValue(column, out var v) ? v : "";
static double Num(Dictionary<string, string> row, string column) => double.TryParse(Cell(row, column), out var n) ? n : 0;

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