register-referentie/services/domain/Big.Api/Program.cs

using Big.Application;
using Big.Domain;
using Big.Infrastructure;

var builder = WebApplication.CreateBuilder(args);

// Options bound from configuration (compose sets Flowable__* and Acl__* env vars).
builder.Services.AddSingleton(sp => sp.GetRequiredService<IConfiguration>()
    .GetSection("Flowable").Get<FlowableOptions>()
    ?? throw new InvalidOperationException("Missing configuration section 'Flowable'"));
builder.Services.AddSingleton(sp => sp.GetRequiredService<IConfiguration>()
    .GetSection("Acl").Get<AclOptions>()
    ?? throw new InvalidOperationException("Missing configuration section 'Acl'"));

// The in-memory registration store is shared between the submit endpoint and the worker (ADR-0009).
builder.Services.AddSingleton<IRegistrationStore, InMemoryRegistrationStore>();

// The Workflow Client is one type behind two ports (start side + worker side); both resolve to the
// same HttpClient-backed implementation — the only code that talks to Flowable (§8.2).
builder.Services.AddHttpClient<FlowableWorkflowClient>();
builder.Services.AddTransient<IWorkflowClient>(sp => sp.GetRequiredService<FlowableWorkflowClient>());
builder.Services.AddTransient<IExternalWorkerClient>(sp => sp.GetRequiredService<FlowableWorkflowClient>());
builder.Services.AddTransient<IUserTaskClient>(sp => sp.GetRequiredService<FlowableWorkflowClient>());
builder.Services.AddTransient<IBeoordelingEscalatieClient>(sp => sp.GetRequiredService<FlowableWorkflowClient>());
builder.Services.AddTransient<IRegistratieVerlopenClient>(sp => sp.GetRequiredService<FlowableWorkflowClient>());
builder.Services.AddHttpClient<IAclClient, AclHttpClient>();

builder.Services.AddScoped<SubmitRegistration>();
builder.Services.AddScoped<ApproveRegistration>();
builder.Services.AddScoped<BeoordeelRegistratie>();
builder.Services.AddScoped<WithdrawRegistration>();
builder.Services.AddScoped<ProvideDocuments>();
builder.Services.AddScoped<Werkbak>();
builder.Services.AddScoped<OpenZaakWorker>();
builder.Services.AddScoped<OpenZaakJobProcessor>();
builder.Services.AddScoped<BeoordelingEscalatieProcessor>();
builder.Services.AddScoped<ExpireRegistrationWorker>();
builder.Services.AddScoped<RegistratieVerlopenProcessor>();

// The hosted external-task job worker polls Flowable and drives OpenZaakAanmaken to completion.
builder.Services.AddHostedService<OpenZaakJobPump>();
// The escalation worker polls the BeoordelingEscaleren jobs the 14-day timer parks and reassigns
// each overdue beoordeling to the teamlead (S-14).
builder.Services.AddHostedService<BeoordelingEscalatiePump>();
// The document-timeout worker polls the RegistratieVerlopen jobs the 30-day timer on WachtOpDocumenten
// parks and expires each lapsed registration to VERLOPEN (S-10a, ADR-0017).
builder.Services.AddHostedService<RegistratieVerlopenPump>();

var app = builder.Build();

app.MapGet("/health", () => "Healthy");

// Submit a registration. The aggregate is created (INGEDIEND) and the registratie process started;
// the zaak is opened later, off the request path, by the worker — so this returns 202 Accepted with
// a location to read the registration's progress (ADR-0009, eventual consistency).
app.MapPost("/registrations", async (SubmitRegistrationRequest body, SubmitRegistration submit, CancellationToken ct) =>
{
    // Diploma origin defaults to domestic; a foreign (eIDAS) submission passes "Buitenlands" so the
    // workflow's DMN routes it through CBGV-advies (S-13). An unknown value is a bad request.
    if (!Enum.TryParse<DiplomaOrigin>(body.DiplomaOrigin, ignoreCase: true, out var origin) && body.DiplomaOrigin is not null)
        return Results.BadRequest(new { error = $"Unknown diplomaOrigin '{body.DiplomaOrigin}'. Expected 'Binnenlands' or 'Buitenlands'." });

    var id = await submit.HandleAsync(new SubmitRegistrationCommand(body.Bsn, origin), ct);
    return Results.Accepted($"/registrations/{id}", new RegistrationResponse(id.ToString(), RegistrationStatus.Ingediend.ToString(), null));
});

// Temporary admin endpoint (S-09b): approve a registration — the behandelaar's decision, until the
// behandel-portal exists (S-12). The zaak's final status is set via the ACL, which flows back over
// NRC to the projection, making the entry publicly visible as INGESCHREVEN. Idempotent.
app.MapPost("/registrations/{id}/approve", async (string id, ApproveRegistration approve, CancellationToken ct) =>
{
    if (!Guid.TryParse(id, out var guid))
        return Results.NotFound();

    await approve.HandleAsync(new ApproveRegistrationCommand(new RegistrationId(guid)), ct);
    return Results.NoContent();
});

// The behandelaar's beoordeling (S-12): decide a registration goedkeuren (→ INGESCHREVEN, sets the
// zaak's final status via the ACL) or afwijzen (→ AFGEWEZEN). Idempotent. This is the domain contract
// the behandel-portal's decision reaches through the BFF; it supersedes the temporary /approve above,
// which is retired once the portal lands.
app.MapPost("/registrations/{id}/decide", async (string id, DecideRequest body, BeoordeelRegistratie beoordeel, CancellationToken ct) =>
{
    if (!Guid.TryParse(id, out var guid))
        return Results.NotFound();

    if (!Enum.TryParse<BeoordelingsBesluit>(body.Besluit, ignoreCase: true, out var besluit))
        return Results.BadRequest(new { error = $"Unknown besluit '{body.Besluit}'. Expected 'goedkeuren' or 'afwijzen'." });

    await beoordeel.HandleAsync(new BeoordeelRegistratieCommand(new RegistrationId(guid), besluit), ct);
    return Results.NoContent();
});

// Withdraw a registration (S-11): the zorgprofessional pulls their own still-open submission back,
// advancing it to INGETROKKEN and cancelling its workflow. Owner-scoped by the caller's bsn (the BFF
// forwards it from the DigiD token, S-11c); a registration that is unknown or not the caller's is
// 404 (indistinguishable, so ownership isn't leaked). Idempotent.
app.MapPost("/registrations/{id}/withdraw", async (string id, WithdrawRequest body, WithdrawRegistration withdraw, CancellationToken ct) =>
{
    if (!Guid.TryParse(id, out var guid))
        return Results.NotFound();

    if (string.IsNullOrWhiteSpace(body?.Bsn))
        return Results.BadRequest(new { error = "A bsn is required to withdraw a registration." });

    var outcome = await withdraw.HandleAsync(new WithdrawRegistrationCommand(new RegistrationId(guid), body.Bsn), ct);
    return outcome == WithdrawOutcome.Withdrawn ? Results.NoContent() : Results.NotFound();
});

// Provide documents (S-10a): the zorgprofessional supplies the documents their registration is parked
// waiting for, completing the WachtOpDocumenten task so the process advances to beoordeling (ADR-0017).
// Owner-scoped by the caller's bsn (the BFF forwards it from the DigiD token); unknown or not-the-
// caller's is 404 (indistinguishable). Idempotent — completing an already-left wait is a no-op. The
// real file upload + ZGW storage is S-10b; this endpoint is the trigger that unblocks the process.
app.MapPost("/registrations/{id}/documents", async (string id, ProvideDocumentsRequest body, ProvideDocuments provide, CancellationToken ct) =>
{
    if (!Guid.TryParse(id, out var guid))
        return Results.NotFound();

    if (string.IsNullOrWhiteSpace(body?.Bsn))
        return Results.BadRequest(new { error = "A bsn is required to provide documents." });
    if (string.IsNullOrWhiteSpace(body.ContentBase64))
        return Results.BadRequest(new { error = "A document is required." });

    byte[] content;
    try { content = Convert.FromBase64String(body.ContentBase64); }
    catch (FormatException) { return Results.BadRequest(new { error = "The document content is not valid base64." }); }

    var command = new ProvideDocumentsCommand(
        new RegistrationId(guid), body.Bsn, content,
        body.FileName ?? "diploma.pdf", body.ContentType ?? "application/pdf");
    var outcome = await provide.HandleAsync(command, ct);
    return outcome == ProvideDocumentsOutcome.Accepted ? Results.NoContent() : Results.NotFound();
});

// The behandelaar's werkbak (S-12): the registrations awaiting beoordeling, read from the open
// Beoordelen user tasks (§8.2) and enriched with bsn + status. The BFF proxies this behind
// medewerker-realm + behandelaar-role authorization; the domain trusts its callers (§8.3).
app.MapGet("/behandel/werkbak", async (Werkbak werkbak, CancellationToken ct) =>
    Results.Ok(await werkbak.GetAsync(ct)));

// Read a registration. Its zaak URL appears once the worker has opened the zaak (eventually).
app.MapGet("/registrations/{id}", async (string id, IRegistrationStore store, CancellationToken ct) =>
{
    if (!Guid.TryParse(id, out var guid))
        return Results.NotFound();

    var registration = await store.GetAsync(new RegistrationId(guid), ct);
    return registration is null
        ? Results.NotFound()
        : Results.Ok(new RegistrationResponse(
            registration.Id.ToString(), registration.Status.ToString(), registration.ZaakUrl?.ToString()));
});

await app.RunAsync();

public sealed record SubmitRegistrationRequest(string Bsn, string? DiplomaOrigin = null);

public sealed record DecideRequest(string Besluit);

public sealed record WithdrawRequest(string Bsn);

public sealed record ProvideDocumentsRequest(string Bsn, string ContentBase64, string? FileName = null, string? ContentType = null);

public sealed record RegistrationResponse(string RegistrationId, string Status, string? ZaakUrl);

public partial class Program;