Update Supplier Contact Info (Email / Central Phone)

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 SupplierId = "10050";           // address.id == supplier.supplier_id
const string Email = "orders@example.com";   // "" leaves the stored value untouched
const string Phone = "319-555-0100";         // "" leaves the stored value untouched
// ---------------------------------------------------------------------------

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 payload = new
{
    Name = "Address",
    UseCodeValues = false,
    IgnoreDisabled = true,
    Transactions = new[]
    {
        new
        {
            Status = "New",   // the upsert shape — an existing id updates that record
            DataElements = new object[]
            {
                new
                {
                    Name = "TABPAGE_1.tp_1_dw_1",
                    Type = "Form",
                    Keys = new[] { "id" },
                    Rows = new object[]
                    {
                        new
                        {
                            Edits = new[]
                            {
                                new { Name = "id", Value = SupplierId, IgnoreIfEmpty = false },
                            },
                        },
                    },
                },
                new
                {
                    Name = "TABPAGE_3.tp_3_dw_3",
                    Type = "Form",
                    Keys = Array.Empty<string>(),
                    Rows = new object[]
                    {
                        new
                        {
                            // IgnoreIfEmpty: an empty value is a NO-OP, never a clear
                            Edits = new[]
                            {
                                new { Name = "email_address", Value = Email,
                                      IgnoreIfEmpty = true },
                                new { Name = "address_central_phone_number", Value = Phone,
                                      IgnoreIfEmpty = true },
                            },
                        },
                    },
                },
            },
        },
    },
};

using var resp = await client.PostAsync(
    $"{uiServer}/api/v2/transaction",
    new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json"));
resp.EnsureSuccessStatusCode();   // HTTP 200 even on failure -- check the Summary
var body = await resp.Content.ReadAsStringAsync();
using var result = JsonDocument.Parse(body);
var summary = result.RootElement.GetProperty("Summary");
var failed = summary.GetProperty("Failed").GetInt32();
Console.WriteLine($"Succeeded: {summary.GetProperty("Succeeded")}, Failed: {failed}");
if (failed > 0)
{
    throw new InvalidOperationException(
        $"Address write failed: {body[..Math.Min(300, body.Length)]}");
}

// --- Read back (TransactionStates shape; the top-level Keys shape returns
//     a blank template with HTTP 200 and reads like a missing record) ---
var getPayload = new
{
    ServiceName = "Address",
    TransactionStates = new[]
    {
        new
        {
            DataElementName = "TABPAGE_1.tp_1_dw_1",
            Keys = new[] { new { Name = "id", Value = SupplierId } },
        },
        new
        {
            DataElementName = "TABPAGE_3.tp_3_dw_3",
            Keys = new[] { new { Name = "id", Value = SupplierId } },
        },
    },
};
using var getResp = await client.PostAsync(
    $"{uiServer}/api/v2/transaction/get",
    new StringContent(JsonSerializer.Serialize(getPayload), Encoding.UTF8, "application/json"));
getResp.EnsureSuccessStatusCode();
using var getResult = JsonDocument.Parse(await getResp.Content.ReadAsStringAsync());

var wanted = new[] { "id", "email_address", "address_central_phone_number" };
foreach (var txn in getResult.RootElement.GetProperty("Transactions").EnumerateArray())
{
    foreach (var de in txn.GetProperty("DataElements").EnumerateArray())
    {
        foreach (var row in de.GetProperty("Rows").EnumerateArray())
        {
            foreach (var edit in row.GetProperty("Edits").EnumerateArray())
            {
                var name = edit.GetProperty("Name").GetString();
                if (wanted.Contains(name))
                {
                    Console.WriteLine($"  {name}: {edit.GetProperty("Value")}");
                }
            }
        }
    }
}

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

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