Create Bins (Bulk)

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 LocationId = "10";                        // stocking location
const int BatchSize = 20;   // tens of transactions per POST is fine and fast
var newBinIds = new[] { "A01-02-01", "A01-02-02", "A01-02-03", "A01-02-04" };
// Constants cloned from a "twin" bin of the same bin_type at this location.
// Flags come back Y/N from the database — convert to ON/OFF for the form.
var twin = new (string Name, string Value)[]
{
    ("bin_type", "SHELF"),
    ("putaway_zone_id", "ZONE-A"), ("pick_zone_id", "ZONE-A"),
    ("bin_length", "10"), ("bin_width", "10"), ("bin_height", "11"),
    ("warehouse_sequence", "1"), ("putaway_zone_sequence", "1"), ("pick_zone_sequence", "1"),
    ("max_unique_items", "0"),
    ("pick_locked_flag", "OFF"), ("put_locked_flag", "OFF"),
    ("full_flag", "OFF"), ("frozen_flag", "OFF"),
    ("consolidation_bin_flag", "OFF"), ("stage_bin_flag", "OFF"), ("door_bin_flag", "OFF"),
};
// ---------------------------------------------------------------------------

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

object BuildBinTransaction(string binId)
{
    var edits = new List<object>
    {
        new { Name = "company_id", Value = CompanyId },
        new { Name = "location_id", Value = LocationId },
        new { Name = "bin_id", Value = binId },
    };
    foreach (var (name, value) in twin)
    {
        edits.Add(new { Name = name, Value = value });
    }

    return new
    {
        Status = "New",
        DataElements = new object[]
        {
            new
            {
                Name = "FORM.form",
                Type = "Form",
                Keys = new[] { "company_id", "location_id", "bin_id" },
                Rows = new object[] { new { Edits = edits } },
            },
        },
    };
}

// Skip-existing check via p21_view_bin (raw bin table isn't always in OData)
var existing = new HashSet<string>();
foreach (var row in await ODataAsync(
    client, "view/p21_view_bin", $"location_id eq {LocationId}", "bin_id"))
{
    existing.Add(row.GetProperty("bin_id").GetString()!);
}

var toCreate = newBinIds.Where(b => !existing.Contains(b)).ToList();
Console.WriteLine($"{newBinIds.Length - toCreate.Count} already exist, creating {toCreate.Count}");

var batchNo = 0;
foreach (var batch in toCreate.Chunk(BatchSize))
{
    batchNo++;
    var payload = new
    {
        Name = "BinLocation",
        UseCodeValues = false,
        // TOP LEVEL — inside a Transaction it is silently ignored
        IgnoreDisabled = true,
        Transactions = batch.Select(BuildBinTransaction).ToArray(),
    };
    using var resp = await client.PostAsync(
        $"{uiServer}/api/v2/transaction",
        new StringContent(JsonSerializer.Serialize(payload), Encoding.UTF8, "application/json"));
    resp.EnsureSuccessStatusCode();
    using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());

    var summary = doc.RootElement.GetProperty("Summary");
    var failed = summary.GetProperty("Failed").GetInt32();
    Console.WriteLine($"Batch {batchNo}: " +
                      $"Succeeded={summary.GetProperty("Succeeded")}, Failed={failed}");
    if (failed > 0 && doc.RootElement.TryGetProperty("Messages", out var messages))
    {
        Console.WriteLine($"  {messages}");
    }

    // Transactions pass/fail independently — check each one
    if (doc.RootElement.TryGetProperty("Results", out var results) &&
        results.TryGetProperty("Transactions", out var txns))
    {
        foreach (var (binId, txn) in batch.Zip(txns.EnumerateArray()))
        {
            if (txn.GetProperty("Status").GetString() != "Passed")
            {
                Console.WriteLine($"  FAILED: {binId}");
            }
        }
    }
}

// Read back every created bin through p21_view_bin (mirrors the Verify section)
foreach (var binId in toCreate)
{
    var rows = await ODataAsync(
        client, "view/p21_view_bin",
        $"location_id eq {LocationId} and bin_id eq '{binId}'", null);
    Console.WriteLine($"{binId}: {(rows.Count > 0 ? "found" : "MISSING")}");
}

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

static async Task<List<JsonElement>> ODataAsync(
    HttpClient client, string path, string filter, string? select)
{
    var url = $"{BaseUrl}/odataservice/odata/{path}?$filter={Uri.EscapeDataString(filter)}";
    if (select is not null) url += $"&$select={select}";
    using var response = await client.GetAsync(url);
    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;
}