Edit Contract Bin Quantities

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 ContractNo = "JOB-1001";
const string JobNo = "31";              // unique across renewals
const string CustomerId = "100198";
const string ShipToId = "200";
// Per bin: the line's item_id, the bin id, and the new quantities.
var binEdits = new (string ItemId, string BinId, int Min, int Max, int Reorder, int Capacity)[]
{
    ("WIDGET-001", "A01-02", 30, 100, 40, 100),
    ("WIDGET-002", "A01-02", 5, 50, 10, 50),
};
// ---------------------------------------------------------------------------

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

static object Edit(string name, string value) => new { Name = name, Value = value };

object BuildBinPayload()
{
    var elements = new List<object>
    {
        new
        {
            Name = "FORM.d_dw_job_price_hdr",
            Type = "Form",
            Keys = Array.Empty<string>(),
            Rows = new object[]
            {
                new
                {
                    Edits = new[]
                    {
                        Edit("job_no", JobNo),
                        Edit("customer_id", CustomerId),
                        Edit("ship_to_id", ShipToId),
                    },
                },
            },
        },
    };
    foreach (var e in binEdits)
    {
        elements.Add(new
        {
            Name = "JOBPRICELINE.jobpriceline",
            Type = "List",
            Keys = new[] { "item_id" },   // select by item_id, NOT line_no
            Rows = new object[] { new { Edits = new[] { Edit("item_id", e.ItemId) } } },
        });
        elements.Add(new
        {
            Name = "BINS.bins",
            Type = "List",
            Keys = new[] { "contract_bin_id", "customer_id", "ship_to_id" },
            Rows = new object[]
            {
                new
                {
                    Edits = new[]
                    {
                        Edit("contract_bin_id", e.BinId),
                        Edit("customer_id", CustomerId),
                        Edit("ship_to_id", ShipToId),
                        Edit("min_qty", e.Min.ToString()),
                        Edit("max_qty", e.Max.ToString()),
                        Edit("reorder_qty", e.Reorder.ToString()),
                        Edit("capacity", e.Capacity.ToString()),
                    },
                },
            },
        });
    }
    return new
    {
        Name = "JobContractPricing",
        UseCodeValues = false,
        IgnoreDisabled = true,  // top level — mandatory for the BINS sub-tab
        Transactions = new object[] { new { Status = "New", DataElements = elements } },
    };
}

using var resp = await client.PostAsync(
    $"{uiServer}/api/v2/transaction",
    new StringContent(JsonSerializer.Serialize(BuildBinPayload()), Encoding.UTF8, "application/json"));
resp.EnsureSuccessStatusCode();  // HTTP 200 even when the transaction failed
using var result = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
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($"  FAILED: {messages}");
    }
    return;
}

// --- Verify via OData (no joins: chain the uid columns) ---
// Renewals can return two headers for one contract_no — match job_no too.
var hdr = (await ODataAsync(client, "job_price_hdr",
    $"contract_no eq '{ContractNo}' and job_no eq '{JobNo}'"))[0];
foreach (var e in binEdits)
{
    var imUid = (await ODataAsync(client, "inv_mast", $"item_id eq '{e.ItemId}'"))[0]
        .GetProperty("inv_mast_uid");
    var line = (await ODataAsync(client, "job_price_line",
        $"job_price_hdr_uid eq {hdr.GetProperty("job_price_hdr_uid")} " +
        $"and inv_mast_uid eq {imUid}"))[0];
    foreach (var binRow in await ODataAsync(client, "job_price_bin",
        $"job_price_line_uid eq {line.GetProperty("job_price_line_uid")}"))
    {
        Console.WriteLine(
            $"{e.ItemId}: min={binRow.GetProperty("min_qty")} " +
            $"max={binRow.GetProperty("max_qty")} " +
            $"reorder={binRow.GetProperty("reorder_qty")} " +
            $"(expected {e.Min}/{e.Max}/{e.Reorder})");
    }
}

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

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