Write Off Small Residual Inventory Cost (Edit Inventory Cost)

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 ItemId = "WIDGET-001";
const string LocationId = "10";
const string NewCost = "0.02";          // the new moving average cost per unit
const string AccountNo = "1111100";     // offset GL account, stored form: NO dash
const string YearForPeriod = "2026";    // FISCAL year
const string Period = "12";             // FISCAL period
// ---------------------------------------------------------------------------

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(5) };
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 ReadCostAsync(client);
if (before is null)
{
    Console.WriteLine($"{ItemId} has no inv_loc row at location {LocationId} -- skip it");
    return;
}
Console.WriteLine($"Before: cost {before.Value.Cost}, on hand {before.Value.OnHand}");
if (before.Value.Cost == decimal.Parse(NewCost))
{
    Console.WriteLine("Already at the target cost -- nothing to do");
    return;
}

var payload = new
{
    Name = "InventoryCostEdit",
    UseCodeValues = false,
    Transactions = new[]
    {
        new
        {
            Status = "New",
            DataElements = new object[]
            {
                Element("QUERY.query", "List", new[] { "location_id", "item_id" },
                    ("location_id", LocationId), ("item_id", ItemId)),
                Element("FORM.form", "Form", new[] { "location_id", "item_id" },
                    ("location_id", LocationId), ("item_id", ItemId), ("new_cost", NewCost)),
                // year_for_period BEFORE period: the window validates the period
                // against the year already in the form.
                Element("FORM.account", "Form", new[] { "account_no" },
                    ("account_no", AccountNo), ("year_for_period", YearForPeriod),
                    ("period", Period)),
            },
        },
    },
};

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
using var result = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());

var summary = result.RootElement.GetProperty("Summary");
Console.WriteLine($"Succeeded: {summary.GetProperty("Succeeded")}, " +
                  $"Failed: {summary.GetProperty("Failed")}");
if (summary.GetProperty("Failed").GetInt32() > 0)
{
    if (result.RootElement.TryGetProperty("Messages", out var messages))
    {
        Console.Error.WriteLine($"  {messages}");
    }
    throw new InvalidOperationException("Cost edit failed");
}

var after = await ReadCostAsync(client)
    ?? throw new InvalidOperationException("inv_loc row disappeared");
Console.WriteLine($"After:  cost {after.Cost}, last maintained by {after.MaintainedBy}");
if (after.Cost != decimal.Parse(NewCost))
{
    throw new InvalidOperationException("Read-back does not match -- investigate before continuing");
}

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

// One DataElement with one row; edits keep the order given (it matters on FORM.account).
static object Element(string name, string type, string[] keys, params (string Name, string Value)[] edits) =>
    new
    {
        Name = name,
        Type = type,
        Keys = keys,
        Rows = new[]
        {
            new
            {
                Edits = edits.Select(e => new { e.Name, e.Value }).ToArray(),
                RelativeDateEdits = Array.Empty<object>(),
            },
        },
    };

// inv_loc row for ItemId at LocationId over OData (chained by inv_mast_uid -- no joins).
static async Task<CostRow?> ReadCostAsync(HttpClient client)
{
    var itemUrl = $"{BaseUrl}/odataservice/odata/table/inv_mast" +
                  $"?$filter={Uri.EscapeDataString($"item_id eq '{ItemId}'")}&$select=inv_mast_uid";
    using var items = JsonDocument.Parse(await client.GetStringAsync(itemUrl));
    var itemRows = items.RootElement.GetProperty("value");
    if (itemRows.GetArrayLength() == 0) return null;
    var uid = itemRows[0].GetProperty("inv_mast_uid").GetRawText();

    // location_id and inv_mast_uid are numeric -- no quotes
    var locUrl = $"{BaseUrl}/odataservice/odata/table/inv_loc" +
                 $"?$filter={Uri.EscapeDataString($"inv_mast_uid eq {uid} and location_id eq {LocationId}")}" +
                 "&$select=moving_average_cost,qty_on_hand,last_maintained_by";
    using var locs = JsonDocument.Parse(await client.GetStringAsync(locUrl));
    var locRows = locs.RootElement.GetProperty("value");
    if (locRows.GetArrayLength() == 0) return null;
    var r = locRows[0];
    return new CostRow(
        r.GetProperty("moving_average_cost").GetDecimal(),
        r.GetProperty("qty_on_hand").GetDecimal(),
        r.GetProperty("last_maintained_by").GetString() ?? "");
}

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

record struct CostRow(decimal Cost, decimal OnHand, string MaintainedBy);