Update Contract Lines

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";
var contract = new
{
    CompanyId = "ACME",
    ContractNo = "JOB-1001",
    JobNo = "31",
    EndDate = "2030-01-01",   // must be >= today
};
// One POST per line: inserts re-save the shared header and collide when batched.
var lines = new (string ItemId, string Uom, decimal Price, decimal? Commission)[]
{
    ("WIDGET-001", "EA", 36.58m, 17.19m),  // already on contract -> updated
    ("WIDGET-002", "EA", 12.40m, null),    // not on contract     -> inserted (upsert)
};
// ---------------------------------------------------------------------------

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

// The payload is a Dictionary so IgnoreDisabled can be added at the TOP LEVEL only
// when it is needed — inside a Transaction object it is silently ignored.
Dictionary<string, object> LinePayload(
    string itemId, string uom, decimal price, decimal? commissionCost)
{
    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("company_id", contract.CompanyId),
                        Edit("contract_no", contract.ContractNo),
                        Edit("job_no", contract.JobNo),
                        Edit("end_date", contract.EndDate),
                    },
                    RelativeDateEdits = Array.Empty<object>(),
                },
            },
        },
        new
        {
            Name = "JOBPRICELINE.jobpriceline",
            Type = "List",
            Keys = new[] { "item_id" },
            Rows = new object[]
            {
                new
                {
                    Edits = new[]
                    {
                        Edit("item_id", itemId),
                        Edit("uom", uom),
                        Edit("pricing_method", "Price"),          // before price!
                        Edit("price", price.ToString()),
                    },
                    RelativeDateEdits = Array.Empty<object>(),
                },
            },
        },
    };
    var payload = new Dictionary<string, object>
    {
        ["Name"] = "JobContractPricing",
        ["UseCodeValues"] = false,
        ["Transactions"] = new object[]
        {
            new { Status = "New", DataElements = elements },
        },
    };
    if (commissionCost is not null)
    {
        payload["IgnoreDisabled"] = true;  // top level, NOT inside the Transaction
        elements.Add(new
        {
            Name = "JOBPRICECOST.jobpricecost",
            Type = "Form",
            Keys = new[] { "item_id" },
            Rows = new object[]
            {
                new
                {
                    Edits = new[]
                    {
                        Edit("item_id", itemId),
                        Edit("commission_cost_type_cd", "Value"),   // type before value
                        Edit("commission_cost_value", commissionCost.Value.ToString()),
                    },
                },
            },
        });
    }
    return payload;
}

async Task<bool> PostLineAsync(Dictionary<string, object> payload)
{
    using var resp = await client.PostAsync(
        $"{uiServer}/api/v2/transaction",
        new StringContent(JsonSerializer.Serialize(payload), 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");
    if (summary.GetProperty("Failed").GetInt32() > 0 ||
        summary.GetProperty("Succeeded").GetInt32() == 0)
    {
        if (result.RootElement.TryGetProperty("Messages", out var messages))
        {
            Console.WriteLine($"  FAILED: {messages}");
        }
        return false;
    }
    return true;
}

foreach (var l in lines)
{
    var ok = await PostLineAsync(LinePayload(l.ItemId, l.Uom, l.Price, l.Commission));
    Console.WriteLine($"{l.ItemId}: {(ok ? "OK" : "failed")}");
}

// --- 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 '{contract.ContractNo}' and job_no eq '{contract.JobNo}'"))[0];
foreach (var l in lines)
{
    var imUid = (await ODataAsync(client, "inv_mast", $"item_id eq '{l.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];
    var actual = line.GetProperty("price").GetDecimal();
    Console.WriteLine($"{l.ItemId}: price={actual} expected={l.Price} -> " +
                      $"{(actual == l.Price ? "OK" : "MISMATCH")}");
}

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