Record Labor Time on a Production Order

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 CompanyId = "ACME";
const string TechnicianId = "300";       // a CONTACT id, not a P21 user id
const string EntryDate = "2030-01-05";   // its accounting period must be OPEN
const string ProdOrder = "1000123";
const string AssemblyItemId = "ASSY-100";        // the assembly LINE's item
const string ComponentLaborId = "LABOR-SHOP";    // the labor component on that line
const string StartTime = "2030-01-05T08:00:00";
const string EndTime = "2030-01-05T12:00:00";
const string LaborTypeCd = "Rate";       // Rate | OT Rate | Prem Rate
// ---------------------------------------------------------------------------

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 = "TimeEntry",
    UseCodeValues = false,
    Transactions = new[]
    {
        new
        {
            Status = "New",
            DataElements = new object[]
            {
                new
                {
                    Name = "TP_TECHNICIAN.tp_technician",
                    Type = "Form",
                    Keys = Array.Empty<string>(),
                    Rows = new[]
                    {
                        new
                        {
                            Edits = new[]
                            {
                                new { Name = "company_id", Value = CompanyId },
                                new { Name = "technician_id", Value = TechnicianId },
                                new { Name = "entry_date", Value = EntryDate },
                            },
                            RelativeDateEdits = Array.Empty<object>(),
                        },
                    },
                },
                new
                {
                    Name = "TP_LABORRECORDING.prod_order_line_comp_labor",
                    Type = "List",
                    Keys = new[] { "prod_order_number" },
                    Rows = new[]
                    {
                        new
                        {
                            // Strict order: prod_order_number -> item_id ->
                            // component_labor_id -> start_time -> end_time
                            Edits = new[]
                            {
                                new { Name = "prod_order_number", Value = ProdOrder },
                                new { Name = "item_id", Value = AssemblyItemId },
                                new { Name = "component_labor_id", Value = ComponentLaborId },
                                new { Name = "start_time", Value = StartTime },
                                new { Name = "end_time", Value = EndTime },
                                new { Name = "labor_type_cd", Value = LaborTypeCd },
                            },
                            RelativeDateEdits = Array.Empty<object>(),
                        },
                    },
                },
            },
        },
    },
};

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("Time entry failed");
}

// --- Read back the labor grid for the order ---
// time_worked is the ACCUMULATED total, not just this entry.
var getPayload = new
{
    ServiceName = "TimeEntry",
    TransactionStates = new[]
    {
        new
        {
            DataElementName = "TP_LABORRECORDING.prod_order_line_comp_labor",
            Keys = new[] { new { Name = "prod_order_number", Value = ProdOrder } },
        },
    },
};
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());

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())
        {
            var fields = new Dictionary<string, string?>();
            foreach (var edit in row.GetProperty("Edits").EnumerateArray())
            {
                fields[edit.GetProperty("Name").GetString()!] =
                    edit.GetProperty("Value").GetString();
            }
            if (string.IsNullOrEmpty(fields.GetValueOrDefault("prod_order_number"))) continue;
            var laborId = fields.GetValueOrDefault("component_labor_id")
                          ?? fields.GetValueOrDefault("service_labor_id");
            Console.WriteLine($"  {laborId}: " +
                              $"time_worked={fields.GetValueOrDefault("time_worked")}");
        }
    }
}

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