Create a Ship-To

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

// ---- 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";
const string CustomerId = "1001";                       // existing customer
const string AddressName = "ACME Industrial - East Plant";
const string DefaultBranch = "10";
const string PreferredLocationId = "10";
const string TermsId = "1";                             // the STORED terms_id code, not its description
const string InvoiceType = "IN";                        // stored code ("Invoice" is the label)
const string TaxGroupId = "TAX-01";                     // stored tax group code
const string SalesrepId = "200";                        // the rep this ship-to should carry
const string Address1 = "456 Industrial Pkwy";
const string City = "Des Moines";
const string State = "IA";
const string PostalCode = "50309";
const string Country = "USA";
const string Phone = "515-555-0100";
// ---------------------------------------------------------------------------

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

// 1. Find the rep the new ship-to will inherit: the customer's live primary rep.
//    customer_id is numeric on OData -- no quotes.
var inherited = (await ODataAsync(client, "customer_salesrep",
        $"customer_id eq {CustomerId} and row_status_flag eq 704"))
    .Where(r => r.TryGetProperty("primary_salesrep_flag", out var f) && f.GetString() == "Y")
    .Select(r => r.GetProperty("salesrep_id").GetString()!)
    .ToList();
Console.WriteLine($"Customer's primary rep (inherited by the ship-to): {string.Join(", ", inherited)}");

// 2. Salesrep rows: add the wanted rep first, then retire each inherited one.
var repRows = new JsonArray();
if (!(inherited.Count == 1 && inherited[0] == SalesrepId))
{
    repRows.Add(Row(("salesrep_id", SalesrepId), ("primary_salesrep", "Y"),
                    ("commission_percentage", "100")));
    foreach (var rep in inherited.Where(r => r != SalesrepId))
        repRows.Add(Row(("salesrep_id", rep), ("delete_flag", "Y")));
}

var elements = new JsonArray
{
    Form("TABPAGE_1.shiptomain",
        ("company_id", CompanyId), ("customer_id", CustomerId), ("address_name", AddressName),
        ("default_branch", DefaultBranch), ("terms_id", TermsId), ("invoice_type", InvoiceType),
        ("tax_group_id", TaxGroupId), ("phys_address1", Address1), ("phys_city", City),
        ("phys_state", State), ("phys_postal_code", PostalCode), ("phys_country", Country)),
    Form("TABPAGE_2.tp_2_dw_2",
        ("mail_address1", Address1), ("mail_city", City), ("mail_state", State),
        ("mail_postal_code", PostalCode), ("mail_country", Country)),
    Form("TABPAGE_5.tp_5_dw_5", ("central_phone_number", Phone)),
    Form("TABPAGE_OEOPTIONS.tabpage_oeoptions", ("preferred_location_id", PreferredLocationId)),
};
if (repRows.Count > 0)
{
    elements.Add(new JsonObject
    {
        ["Name"] = "TABPAGE_SALESREP.tabpage_salesrep",
        ["Type"] = "List",
        ["Keys"] = new JsonArray("salesrep_id"),
        ["Rows"] = repRows,
    });
}

var payload = new JsonObject
{
    ["Name"] = "ShipTo",
    ["UseCodeValues"] = true,   // send stored codes: terms_id, invoice_type, Y/N flags
    ["Transactions"] = new JsonArray
    {
        new JsonObject { ["Status"] = "New", ["DataElements"] = elements },
    },
};

// 3. Create
using var response = await client.PostAsync(
    $"{uiServer}/api/v2/transaction",
    new StringContent(payload.ToJsonString(), 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("Ship-to create failed");
}

// The generated address_id comes back in the result rows
var shipToId = ResultValue(result.RootElement, "address_id");
Console.WriteLine($"Created ship-to (address_id): {shipToId}");

// 4. Read back via OData -- Succeeded is not proof every value landed
foreach (var row in await ODataAsync(client, "ship_to", $"ship_to_id eq {shipToId}"))
{
    Console.WriteLine(
        $"ship_to_id={Field(row, "ship_to_id")} customer_id={Field(row, "customer_id")} " +
        $"default_branch={Field(row, "default_branch")} terms_id={Field(row, "terms_id")}");
}
foreach (var row in await ODataAsync(client, "ship_to_salesrep", $"ship_to_id eq {shipToId}"))
{
    Console.WriteLine(
        $"salesrep_id={Field(row, "salesrep_id")} primary_salesrep={Field(row, "primary_salesrep")} " +
        $"commission_percentage={Field(row, "commission_percentage")} " +
        $"delete_flag={Field(row, "delete_flag")}");
}

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

static JsonObject Row(params (string Name, string Value)[] edits)
{
    var list = new JsonArray();
    foreach (var (name, value) in edits)
        list.Add(new JsonObject { ["Name"] = name, ["Value"] = value });
    return new JsonObject { ["Edits"] = list, ["RelativeDateEdits"] = new JsonArray() };
}

static JsonObject Form(string name, params (string Name, string Value)[] edits) => new()
{
    ["Name"] = name,
    ["Type"] = "Form",
    ["Keys"] = new JsonArray(),
    ["Rows"] = new JsonArray { Row(edits) },
};

static string Field(JsonElement row, string name) =>
    row.TryGetProperty(name, out var v) ? v.ToString() : "";

// Pull one echoed field out of any passed transaction's result rows.
static string? ResultValue(JsonElement root, string fieldName)
{
    string? found = null;
    foreach (var txn in root.GetProperty("Results").GetProperty("Transactions").EnumerateArray())
    {
        if (txn.GetProperty("Status").GetString() != "Passed") continue;
        foreach (var element in txn.GetProperty("DataElements").EnumerateArray())
        {
            foreach (var row in element.GetProperty("Rows").EnumerateArray())
            {
                foreach (var edit in row.GetProperty("Edits").EnumerateArray())
                {
                    if (edit.GetProperty("Name").GetString() == fieldName)
                    {
                        var value = edit.GetProperty("Value").GetString();
                        if (!string.IsNullOrEmpty(value)) found = value;
                    }
                }
            }
        }
    }
    return found;
}

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