Link an Existing Production Order to a Sales-Order Line

// Link an existing production order to an open sales-order line (Interactive API).
// The Production Order window's Transactions To Assign tab fills through the datawindow's
// right-click tool m_retrieveotheropentransactions. Tick `assigned` on the sales-order
// row and save: P21 writes one prod_order_line_link row.
//
//   dotnet run -- [PROD_ORDER ORDER_NO LINE_NO] [--save]
//
// Without --save it retrieves the open transactions and ticks the row, then stops (dry run).
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";
string prodOrder = "1000123";                        // the existing, open production order
string orderNo = "1001234";                          // the sales order to link it to
string lineNo = "1";                                 // that order's production-order assembly line
bool save = false;                                   // true writes the link; false is a dry run
// ---------------------------------------------------------------------------

const string Tab = "TABPAGE_TRANSACTIONS_TO_ASSIGN";
const string Dw = "tabpage_transactions_to_assign";

var positional = args.Where(a => a != "--save").ToArray();
if (positional.Length is not (0 or 3)) { Console.WriteLine("Pass all three record numbers, or none to use the constants"); return; }
if (positional.Length == 3) { prodOrder = positional[0]; orderNo = positional[1]; lineNo = positional[2]; }
if (args.Contains("--save")) save = true;
foreach (var value in new[] { prodOrder, orderNo, lineNo })
    if (value.Length == 0 || !value.All(char.IsAsciiDigit))   // these go into an OData filter
    { Console.WriteLine($"Not a number: {value}"); return; }

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";

await SendAsync(HttpMethod.Post, $"{iapi}/sessions", new { ResponseWindowHandlingEnabled = true }, "open session");
var windowId = "";
try
{
    var opened = await SendAsync(HttpMethod.Post, $"{iapi}/v2/window", new { ServiceName = "ProductionOrder" }, "open ProductionOrder");
    windowId = opened.GetProperty("WindowId").GetString()!;

    // 1. Load the production order, 2. switch to the Transactions To Assign tab.
    await ChangeAsync(windowId, "TABPAGE_1", "tp_1_dw_1", "prod_order_number", prodOrder);
    await SendAsync(HttpMethod.Put, $"{iapi}/v2/tab", new { WindowId = windowId, PageName = Tab }, "select tab");

    // 3. The grid's right-click tool fills it with open, unassigned demand. The window-level
    //    tool list does not show it; ask for the datawindow's tools:
    //    GET /v2/tools?windowId=...&dwName=tabpage_transactions_to_assign
    await SendAsync(HttpMethod.Post, $"{iapi}/v2/tools", new
    {
        WindowId = windowId, ToolName = "m_retrieveotheropentransactions",
        DatawindowName = Dw, FieldName = (string?)null, Row = 0, Text = (string?)null,
    }, "retrieve");
    var grid = await RowsAsync(windowId, Dw);
    var match = -1;
    for (var i = 0; i < grid.Count; i++)
    {
        var row = grid[i];
        Console.WriteLine($"  open: {Cell(row, "cf_transaction_type")} {Cell(row, "trans_number")}" +
            $" line {Cell(row, "line_number")} assigned={Cell(row, "assigned")} remaining={Cell(row, "qty_remaining")}");
        if (Cell(row, "cf_transaction_type") == "Sales Order"
            && Number(Cell(row, "trans_number")) == orderNo
            && Number(Cell(row, "line_number")) == lineNo)
            match = i;
    }
    if (match < 0) { Console.WriteLine("That sales-order line is not among the open transactions"); return; }

    // 4. Make it the current row (1-based), 5. tick `assigned`; P21 fills qty_to_assign.
    await SendAsync(HttpMethod.Put, $"{iapi}/v2/row", new { WindowId = windowId, DatawindowName = Dw, Row = match + 1 }, "select row");
    await ChangeAsync(windowId, Tab, Dw, "assigned", "ON");
    var ticked = (await RowsAsync(windowId, Dw))[match];
    Console.WriteLine($"  ticked: assigned={Cell(ticked, "assigned")} qty_to_assign={Cell(ticked, "qty_to_assign")}");
    if (!save) { Console.WriteLine("Dry run: not saved (set save = true or pass --save)"); return; }

    // 6. Save -- the body is the bare window id.
    await SendAsync(HttpMethod.Put, $"{iapi}/v2/data", windowId, "save");
    Console.WriteLine("  saved");
}
finally
{
    if (windowId.Length > 0) await client.DeleteAsync($"{iapi}/v2/window?id={windowId}");
    await client.DeleteAsync($"{iapi}/sessions");
}

// Read back: one prod_order_line_link row whose transaction_uid is the sales line's uid.
var lines = await ODataAsync("oe_line", $"order_no eq '{orderNo}' and line_no eq {lineNo}");
var links = await ODataAsync("prod_order_line_link", $"prod_order_number eq {prodOrder}");
var lineUid = lines[0].GetProperty("oe_line_uid").GetDecimal();
Console.WriteLine($"  oe_line: uid {lineUid:0} assembly={lines[0].GetProperty("assembly")} disposition={lines[0].GetProperty("disposition")}");
foreach (var link in links)
    Console.WriteLine($"  link: order {link.GetProperty("prod_order_number")} line {link.GetProperty("prod_order_line_number")}" +
        $" trans_type={link.GetProperty("trans_type")} quantity={link.GetProperty("quantity")}" +
        $" row_status_flag={link.GetProperty("row_status_flag")} transaction_uid={link.GetProperty("transaction_uid")}");
if (!links.Any(l => l.GetProperty("transaction_uid").GetDecimal() == lineUid))
{ Console.WriteLine("No prod_order_line_link row for that sales-order line"); return; }
Console.WriteLine("Linked.");

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

// One Interactive call; refuses HTTP errors, Status 2 (failure) and Status 3 (a prompt).
async Task<JsonElement> SendAsync(HttpMethod method, string url, object body, string what)
{
    using var request = new HttpRequestMessage(method, url)
    {
        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 status)
        && status.ValueKind == JsonValueKind.Number && status.GetInt32() is 2 or 3)
        throw new InvalidOperationException($"{what}: Status {status}: {answer.GetProperty("Messages")}");
    return answer;
}

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

// The rows of one datawindow on the active surface, as column -> value maps.
async Task<List<Dictionary<string, string>>> RowsAsync(string window, string dwName)
{
    var json = await client.GetStringAsync($"{iapi}/v2/data?id={window}");
    var rows = new List<Dictionary<string, string>>();
    foreach (var dw in JsonDocument.Parse(json).RootElement.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 data) || data.ValueKind != JsonValueKind.Array) continue;
        foreach (var row in data.EnumerateArray())
        {
            var map = new Dictionary<string, string>();
            var cells = row.EnumerateArray().ToList();
            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;
}

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

// Normalize a decimal string such as "1001234.0" to "1001234".
static string Number(string value) => value.Split('.')[0];

// One OData table read.
async Task<List<JsonElement>> ODataAsync(string table, string filter)
{
    var url = $"{BaseUrl}/odataservice/odata/table/{table}?$filter={Uri.EscapeDataString(filter)}";
    var response = await client.GetAsync(url);
    response.EnsureSuccessStatusCode();
    return JsonDocument.Parse(await response.Content.ReadAsStringAsync())
        .RootElement.GetProperty("value").EnumerateArray().Select(e => e.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;
}