Modify an Existing Sales Order

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 OrderNo = "1001234";
// (user_line_no, oe_order_item_id, unit_quantity): an EXISTING handle updates
// that line in place, a NEW handle inserts a line.
var lines = new (string Handle, string ItemId, string Quantity)[]
{
    ("010", "WIDGET-001", "4"),
    ("030", "WIDGET-002", "1"),
};
// ---------------------------------------------------------------------------

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 before = await ReadLinesAsync(client, uiServer);
Console.WriteLine($"Before: {before.Count} line(s)");
foreach (var row in before)
{
    Console.WriteLine($"  {row["user_line_no"]}: {row["oe_order_item_id"]} x {row["unit_quantity"]}");
}

var payload = new
{
    Name = "Order",
    UseCodeValues = false,
    Transactions = new[]
    {
        new
        {
            Status = "New",
            DataElements = new object[]
            {
                // ONLY the key. Re-sending header fields fails on disabled
                // columns (customer_id) once the order exists.
                new
                {
                    Name = "TABPAGE_1.order",
                    Type = "Form",
                    Keys = new[] { "order_no" },
                    Rows = new object[]
                    {
                        new
                        {
                            Edits = new[] { new { Name = "order_no", Value = OrderNo } },
                            RelativeDateEdits = Array.Empty<object>(),
                        },
                    },
                },
                new
                {
                    Name = "TP_ITEMS.items",
                    Type = "List",
                    Keys = new[] { "user_line_no" },
                    Rows = lines.Select(l => (object)new
                    {
                        Edits = new[]
                        {
                            new { Name = "user_line_no", Value = l.Handle },
                            new { Name = "oe_order_item_id", Value = l.ItemId },
                            new { Name = "unit_quantity", Value = l.Quantity },
                        },
                        RelativeDateEdits = Array.Empty<object>(),
                    }).ToArray(),
                },
            },
        },
    },
};

using var response = await client.PostAsync(
    $"{uiServer}/api/v2/transaction",
    new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json"));
response.EnsureSuccessStatusCode();
using var result = JsonDocument.Parse(await response.Content.ReadAsStringAsync());

// HTTP 200 even on failure -- check the Summary, never the status code
var summary = result.RootElement.GetProperty("Summary");
var succeeded = summary.GetProperty("Succeeded").GetInt32();
var failed = summary.GetProperty("Failed").GetInt32();
Console.WriteLine($"Succeeded: {succeeded}, Failed: {failed}");
if (failed > 0 || succeeded == 0)
{
    if (result.RootElement.TryGetProperty("Messages", out var messages))
    {
        Console.Error.WriteLine(messages);
    }
    throw new InvalidOperationException("Order update failed");
}

// Read back: each handle carries its value, and no unexpected line appeared
var after = await ReadLinesAsync(client, uiServer);
Console.WriteLine($"After: {after.Count} line(s)");
foreach (var (handle, itemId, quantity) in lines)
{
    var row = after.FirstOrDefault(r => r["user_line_no"] == handle);
    var landed = row is not null && row["oe_order_item_id"] == itemId
        && decimal.Parse(row["unit_quantity"]) == decimal.Parse(quantity);
    var detail = row is null ? "" : $" ({row["oe_order_item_id"]} x {row["unit_quantity"]})";
    Console.WriteLine($"  {handle}: {(landed ? "OK" : "NOT APPLIED")}{detail}");
}
var expected = before.Select(r => r["user_line_no"])
    .Union(lines.Select(l => l.Handle)).Count();
if (after.Count != expected)
{
    Console.WriteLine($"WARNING: expected {expected} lines, found {after.Count} -- a key " +
                      "problem appends lines while reporting Succeeded (see Gotchas)");
}

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

// Read the order's lines back with /transaction/get -- the only proof.
static async Task<List<Dictionary<string, string>>> ReadLinesAsync(HttpClient client, string uiServer)
{
    var request = JsonSerializer.Serialize(new
    {
        ServiceName = "Order",
        TransactionStates = new[]
        {
            new
            {
                DataElementName = "TABPAGE_1.order",
                Keys = new[] { new { Name = "order_no", Value = OrderNo } },
            },
        },
    });
    using var response = await client.PostAsync($"{uiServer}/api/v2/transaction/get",
        new StringContent(request, Encoding.UTF8, "application/json"));
    response.EnsureSuccessStatusCode();
    using var doc = JsonDocument.Parse(await response.Content.ReadAsStringAsync());
    var rows = new List<Dictionary<string, string>>();
    foreach (var element in doc.RootElement.GetProperty("Transactions")[0]
                 .GetProperty("DataElements").EnumerateArray())
    {
        if (element.GetProperty("Name").GetString() != "TP_ITEMS.items") continue;
        foreach (var row in element.GetProperty("Rows").EnumerateArray())
        {
            var edits = row.GetProperty("Edits").EnumerateArray().ToDictionary(
                e => e.GetProperty("Name").GetString()!,
                e => e.GetProperty("Value").GetString() ?? "");
            if (!string.IsNullOrEmpty(edits.GetValueOrDefault("oe_order_item_id")))
            {
                rows.Add(edits);
            }
        }
    }
    return rows;
}

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