Mijn aanvragen (A): backend Aanvraag store + lifecycle endpoints

Adds the backend-owned Aanvraag aggregate (PRD 0001, phase A) — the system of
record the dashboard will read. In-memory static store mirroring DocumentStore.

- ApplicationStore: create/get/list/draft-sync/cancel/submit; status COMPUTED ON
  READ (Mappers.ToStatusDto(now)) so auto-approval is pure timestamp arithmetic,
  no timers/jobs (ProcessingWindow = 8s).
- Endpoints: GET /applications, GET/POST/PUT/DELETE /applications/{id},
  POST /applications/{id}/submit.
- Lifecycle: registratie duo -> auto (Goedgekeurd after window), handmatig ->
  manual pending (no 422); herregistratie/intake 0 uren -> Afgewezen else auto.
  Cancel blocks submitted aanvragen (409, no withdrawal in scope).
- Old /registrations endpoint + RejectRegistratie 422 left intact (retire in E).
- ApplicationTests: lifecycle + auto-approve window boundary (pure). 54/54 green.

Also checks in the PRD (docs/prd/0001).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

backend/src/BigRegister.Api/Contracts/Dtos.cs

@@ -71,3 +71,39 @@ public sealed record HerregistratieRequest(int Uren, IReadOnlyList<DocumentRefDt
 public sealed record ChangeRequestRequest(string Straat, string Postcode, string Woonplaats);
 
 public sealed record ReferentieResponse(string Referentie);
+
+// --- Applications (aanvragen): the system of record for the dashboard. ---
+
+// Status is a discriminated union by Tag (Concept | InBehandeling | Goedgekeurd |
+// Afgewezen); only the fields relevant to a tag are populated. Mirrors the FE union.
+public sealed record AanvraagStatusDto(
+    string Tag,
+    int? StepIndex = null,
+    int? StepCount = null,
+    string? Referentie = null,
+    bool? Manual = null,
+    string? Reden = null);
+
+public sealed record ApplicationSummaryDto(
+    string Id, string Type, AanvraagStatusDto Status,
+    IReadOnlyList<string> DocumentIds,
+    string CreatedAt, string UpdatedAt, string? SubmittedAt);
+
+public sealed record ApplicationDetailDto(
+    string Id, string Type, AanvraagStatusDto Status,
+    System.Text.Json.JsonElement? Draft,
+    IReadOnlyList<string> DocumentIds,
+    string CreatedAt, string UpdatedAt, string? SubmittedAt);
+
+public sealed record CreateApplicationRequest(string Type);
+
+public sealed record DraftSyncRequest(
+    System.Text.Json.JsonElement Draft, int StepIndex, int StepCount,
+    IReadOnlyList<string>? DocumentIds = null);
+
+// Submit carries only the fields the server re-validates per wizard type.
+public sealed record SubmitApplicationRequest(
+    string? DiplomaHerkomst = null, int? Uren = null,
+    IReadOnlyList<DocumentRefDto>? Documents = null);
+
+public sealed record SubmitApplicationResponse(string Referentie, AanvraagStatusDto Status);

backend/src/BigRegister.Api/Contracts/Mappers.cs

@@ -1,3 +1,4 @@
+using BigRegister.Api.Data;
 using BigRegister.Domain.Diplomas;
 using BigRegister.Domain.Documents;
 using BigRegister.Domain.People;
@@ -34,4 +35,27 @@ public static class Mappers
 
     public static DocumentCategoryDto ToDto(this DocumentCategory c) => new(
         c.CategoryId, c.Label, c.Description, c.Required, c.AcceptedTypes, c.MaxSizeMb, c.Multiple, c.AllowPostDelivery);
+
+    // Aanvraag status is COMPUTED ON READ: an auto-approvable submission reports
+    // Goedgekeurd once past the processing window, else In behandeling; a manual case
+    // stays In behandeling forever (awaits the unbuilt backoffice). Pure — testable
+    // by passing different `now` values without waiting for the wall clock.
+    public static AanvraagStatusDto ToStatusDto(this Aanvraag a, DateTimeOffset now)
+    {
+        if (!a.Submitted)
+            return new("Concept", StepIndex: a.StepIndex, StepCount: a.StepCount);
+        if (a.Reden is not null)
+            return new("Afgewezen", Referentie: a.Referentie, Reden: a.Reden);
+        if (a.AutoApprovable && now > a.SubmittedAt!.Value + ApplicationStore.ProcessingWindow)
+            return new("Goedgekeurd", Referentie: a.Referentie);
+        return new("InBehandeling", Referentie: a.Referentie, Manual: !a.AutoApprovable);
+    }
+
+    public static ApplicationSummaryDto ToSummaryDto(this Aanvraag a, DateTimeOffset now) => new(
+        a.Id, a.Type, a.ToStatusDto(now), a.DocumentIds,
+        a.CreatedAt.ToString("o"), a.UpdatedAt.ToString("o"), a.SubmittedAt?.ToString("o"));
+
+    public static ApplicationDetailDto ToDetailDto(this Aanvraag a, DateTimeOffset now) => new(
+        a.Id, a.Type, a.ToStatusDto(now), a.Draft, a.DocumentIds,
+        a.CreatedAt.ToString("o"), a.UpdatedAt.ToString("o"), a.SubmittedAt?.ToString("o"));
 }

backend/src/BigRegister.Api/Data/ApplicationStore.cs

@@ -0,0 +1,110 @@
+using System.Text.Json;
+using BigRegister.Domain.Submissions;
+
+namespace BigRegister.Api.Data;
+
+/// <summary>
+/// An application (aanvraag) — the system of record the dashboard reads. A wizard
+/// creates one as a Concept on its first step, syncs its draft snapshot per step,
+/// then submits it into the Concept → In behandeling → Goedgekeurd/Afgewezen
+/// lifecycle (ADR-0002). Status is COMPUTED ON READ (see Mappers.ToStatusDto) so
+/// auto-approval is purely a function of stored timestamps — no timers, no jobs.
+/// </summary>
+public sealed class Aanvraag
+{
+    public required string Id { get; init; }
+    public required string Type { get; init; }   // registratie | herregistratie | intake
+    public required string Owner { get; init; }
+    public JsonElement? Draft { get; set; }       // opaque wizard machine snapshot (Concept only)
+    public int StepIndex { get; set; }
+    public int StepCount { get; set; }
+    public List<string> DocumentIds { get; set; } = new();
+    public string? Referentie { get; set; }       // set on submit
+    public bool AutoApprovable { get; set; }       // set on submit: duo (registratie) / other types
+    public string? Reden { get; set; }             // set on submit when rejected → Afgewezen
+    public bool Submitted { get; set; }
+    public DateTimeOffset CreatedAt { get; init; }
+    public DateTimeOffset UpdatedAt { get; set; }
+    public DateTimeOffset? SubmittedAt { get; set; }
+}
+
+/// <summary>
+/// In-memory application store (no DB), mirrors <see cref="DocumentStore"/>.
+/// ponytail: one global lock — fine for a single-process demo; swap for per-key
+/// locks if it ever serves load.
+/// </summary>
+public static class ApplicationStore
+{
+    /// After this window an auto-approvable submission reports Goedgekeurd (computed on read).
+    public static readonly TimeSpan ProcessingWindow = TimeSpan.FromSeconds(8);
+
+    private static readonly Dictionary<string, Aanvraag> _apps = new();
+    private static readonly object _gate = new();
+
+    public static Aanvraag Create(string type, string owner)
+    {
+        var now = DateTimeOffset.UtcNow;
+        var a = new Aanvraag { Id = Guid.NewGuid().ToString(), Type = type, Owner = owner, CreatedAt = now, UpdatedAt = now };
+        lock (_gate) _apps[a.Id] = a;
+        return a;
+    }
+
+    public static Aanvraag? Get(string id, string owner)
+    {
+        lock (_gate) return _apps.TryGetValue(id, out var a) && a.Owner == owner ? a : null;
+    }
+
+    public static IReadOnlyList<Aanvraag> List(string owner)
+    {
+        lock (_gate) return _apps.Values.Where(a => a.Owner == owner).ToList();
+    }
+
+    /// Draft sync: idempotent upsert of the wizard snapshot. Only a Concept is mutable.
+    public static bool SyncDraft(string id, string owner, JsonElement draft, int stepIndex, int stepCount, IReadOnlyList<string>? documentIds)
+    {
+        lock (_gate)
+        {
+            if (!_apps.TryGetValue(id, out var a) || a.Owner != owner || a.Submitted) return false;
+            a.Draft = draft.Clone();   // detach from the request's JsonDocument (disposed after the call)
+            a.StepIndex = stepIndex;
+            a.StepCount = stepCount;
+            if (documentIds is not null) a.DocumentIds = documentIds.ToList();
+            a.UpdatedAt = DateTimeOffset.UtcNow;
+            return true;
+        }
+    }
+
+    /// Cancel a Concept: remove it and delete its (unlinked) documents. Linked docs
+    /// (belonging to a submitted aanvraag) are left untouched by DocumentStore.
+    public static bool Delete(string id, string owner)
+    {
+        List<string> docs;
+        lock (_gate)
+        {
+            if (!_apps.TryGetValue(id, out var a) || a.Owner != owner) return false;
+            docs = a.DocumentIds.ToList();
+            _apps.Remove(id);
+        }
+        foreach (var d in docs) DocumentStore.DeleteOwned(d, owner);
+        return true;
+    }
+
+    /// Submit transition. reject != null → Afgewezen; else accepted (In behandeling,
+    /// auto-advancing to Goedgekeurd after the window when autoApprovable). Returns null
+    /// if the aanvraag is gone or already submitted (idempotency guard).
+    public static Aanvraag? Submit(string id, string owner, string? reject, bool autoApprovable, IReadOnlyList<string>? documentIds)
+    {
+        lock (_gate)
+        {
+            if (!_apps.TryGetValue(id, out var a) || a.Owner != owner || a.Submitted) return null;
+            a.Submitted = true;
+            a.SubmittedAt = DateTimeOffset.UtcNow;
+            a.UpdatedAt = a.SubmittedAt.Value;
+            a.Referentie = SubmissionRules.NewReference();
+            a.AutoApprovable = autoApprovable;
+            a.Reden = reject;
+            if (documentIds is not null) a.DocumentIds = documentIds.ToList();
+            return a;
+        }
+    }
+}

backend/src/BigRegister.Api/Program.cs

@@ -146,6 +146,85 @@ api.MapDelete("/admin/uploads/{documentId}", (string documentId, HttpContext ctx
 .Produces(StatusCodes.Status403Forbidden)
 .Produces(StatusCodes.Status404NotFound);
 
+// --- Applications (aanvragen): the system of record the dashboard reads. ---
+
+api.MapGet("/applications", () =>
+{
+    var now = DateTimeOffset.UtcNow;
+    return ApplicationStore.List(DocumentStore.DemoOwner)
+        .OrderByDescending(a => a.UpdatedAt)
+        .Select(a => a.ToSummaryDto(now)).ToList();
+});
+
+api.MapGet("/applications/{id}", (string id) =>
+    ApplicationStore.Get(id, DocumentStore.DemoOwner) is { } a
+        ? Results.Ok(a.ToDetailDto(DateTimeOffset.UtcNow))
+        : Results.NotFound())
+.Produces<ApplicationDetailDto>()
+.Produces(StatusCodes.Status404NotFound);
+
+api.MapPost("/applications", (CreateApplicationRequest req) =>
+{
+    var a = ApplicationStore.Create(req.Type, DocumentStore.DemoOwner);
+    return Results.Created($"/api/v1/applications/{a.Id}", a.ToDetailDto(DateTimeOffset.UtcNow));
+})
+.Produces<ApplicationDetailDto>(StatusCodes.Status201Created);
+
+// Draft sync per step — idempotent; keep it debounced on the client (it is chatty).
+api.MapPut("/applications/{id}", (string id, DraftSyncRequest req) =>
+    ApplicationStore.SyncDraft(id, DocumentStore.DemoOwner, req.Draft, req.StepIndex, req.StepCount, req.DocumentIds)
+        ? Results.NoContent() : Results.NotFound())
+.Produces(StatusCodes.Status204NoContent)
+.Produces(StatusCodes.Status404NotFound);
+
+// Cancel a Concept (cascades to its unlinked documents). Submitted aanvragen cannot
+// be withdrawn (out of scope — no "intrekken").
+api.MapDelete("/applications/{id}", (string id) =>
+{
+    var a = ApplicationStore.Get(id, DocumentStore.DemoOwner);
+    if (a is null) return Results.NotFound();
+    if (a.Submitted)
+        return Results.Problem(detail: "Een ingediende aanvraag kan niet worden geannuleerd.", statusCode: StatusCodes.Status409Conflict);
+    ApplicationStore.Delete(id, DocumentStore.DemoOwner);
+    return Results.NoContent();
+})
+.Produces(StatusCodes.Status204NoContent)
+.ProducesProblem(StatusCodes.Status409Conflict)
+.Produces(StatusCodes.Status404NotFound);
+
+// Submit runs the server-owned rules, sets autoApprovable, and transitions the
+// aanvraag. handmatig no longer 422s (ADR-0002): it becomes a manual (pending) case.
+api.MapPost("/applications/{id}/submit", (string id, SubmitApplicationRequest req, HttpContext ctx) =>
+{
+    var existing = ApplicationStore.Get(id, DocumentStore.DemoOwner);
+    if (existing is null) return Results.NotFound();
+    if (existing.Submitted)
+        return Results.Problem(detail: "Aanvraag is al ingediend.", statusCode: StatusCodes.Status409Conflict);
+
+    // Per wizard type: what rejects the submission (→ Afgewezen) and whether it auto-approves.
+    (string? reject, bool autoApprovable) = existing.Type switch
+    {
+        "registratie" => (null, req.DiplomaHerkomst == "duo"),
+        _ /* herregistratie | intake */ => (SubmissionRules.RejectZeroUren(req.Uren ?? 0), true),
+    };
+
+    var docs = req.Documents;
+    if (docs is not null)
+        DocumentStore.Link(docs.Where(d => d.Channel == "digital" && d.DocumentId is not null).Select(d => d.DocumentId!));
+    var documentIds = docs?.Where(d => d.DocumentId is not null).Select(d => d.DocumentId!).ToList();
+
+    var submitted = ApplicationStore.Submit(id, DocumentStore.DemoOwner, reject, autoApprovable, documentIds);
+    if (submitted is null) return Results.Conflict();
+
+    app.Logger.LogInformation(
+        "aanvraag submit id={Id} type={Type} outcome={Outcome} auto={Auto} reference={Reference}",
+        id, existing.Type, reject is null ? "accepted" : "rejected", autoApprovable, submitted.Referentie);
+    return Results.Ok(new SubmitApplicationResponse(submitted.Referentie!, submitted.ToStatusDto(DateTimeOffset.UtcNow)));
+})
+.Produces<SubmitApplicationResponse>()
+.ProducesProblem(StatusCodes.Status409Conflict)
+.Produces(StatusCodes.Status404NotFound);
+
 app.Run();
 
 static bool IsAdmin(HttpContext ctx) => ctx.Request.Headers["X-Admin"] == "true";

backend/tests/BigRegister.Tests/ApplicationTests.cs

@@ -0,0 +1,136 @@
+using System.Net;
+using System.Net.Http.Json;
+using BigRegister.Api.Contracts;
+using BigRegister.Api.Data;
+using Microsoft.AspNetCore.Mvc.Testing;
+
+namespace BigRegister.Tests;
+
+public class ApplicationTests(WebApplicationFactory<Program> factory) : IClassFixture<WebApplicationFactory<Program>>
+{
+    private readonly HttpClient _client = factory.CreateClient();
+
+    private async Task<ApplicationDetailDto> Create(string type = "registratie")
+    {
+        var res = await _client.PostAsJsonAsync("/api/v1/applications", new { type });
+        Assert.Equal(HttpStatusCode.Created, res.StatusCode);
+        return (await res.Content.ReadFromJsonAsync<ApplicationDetailDto>())!;
+    }
+
+    private Task<List<ApplicationSummaryDto>?> List() =>
+        _client.GetFromJsonAsync<List<ApplicationSummaryDto>>("/api/v1/applications");
+
+    // --- Lifecycle over HTTP ---
+
+    [Fact]
+    public async Task Create_then_list_shows_a_concept_with_step_progress()
+    {
+        var a = await Create();
+        await _client.PutAsJsonAsync($"/api/v1/applications/{a.Id}",
+            new { draft = new { beroep = "arts" }, stepIndex = 1, stepCount = 4 });
+
+        var mine = (await List())!.Single(x => x.Id == a.Id);
+        Assert.Equal("Concept", mine.Status.Tag);
+        Assert.Equal(1, mine.Status.StepIndex);
+        Assert.Equal(4, mine.Status.StepCount);
+    }
+
+    [Fact]
+    public async Task Draft_sync_is_readable_back_from_detail()
+    {
+        var a = await Create();
+        await _client.PutAsJsonAsync($"/api/v1/applications/{a.Id}",
+            new { draft = new { beroep = "verpleegkundige" }, stepIndex = 2, stepCount = 4 });
+
+        var detail = await _client.GetFromJsonAsync<ApplicationDetailDto>($"/api/v1/applications/{a.Id}");
+        Assert.NotNull(detail!.Draft);
+        Assert.Equal("verpleegkundige", detail.Draft!.Value.GetProperty("beroep").GetString());
+    }
+
+    [Fact]
+    public async Task Submit_duo_registratie_is_in_behandeling_and_auto()
+    {
+        var a = await Create("registratie");
+        var res = await _client.PostAsJsonAsync($"/api/v1/applications/{a.Id}/submit", new { diplomaHerkomst = "duo" });
+        res.EnsureSuccessStatusCode();
+        var body = (await res.Content.ReadFromJsonAsync<SubmitApplicationResponse>())!;
+        Assert.StartsWith("BIG-2026-", body.Referentie);
+        Assert.Equal("InBehandeling", body.Status.Tag);
+        Assert.False(body.Status.Manual);   // auto-approvable → not a manual case
+    }
+
+    [Fact]
+    public async Task Submit_handmatig_registratie_succeeds_as_manual_case()
+    {
+        var a = await Create("registratie");
+        var res = await _client.PostAsJsonAsync($"/api/v1/applications/{a.Id}/submit", new { diplomaHerkomst = "handmatig" });
+        res.EnsureSuccessStatusCode();   // no longer a 422
+        var body = (await res.Content.ReadFromJsonAsync<SubmitApplicationResponse>())!;
+        Assert.Equal("InBehandeling", body.Status.Tag);
+        Assert.True(body.Status.Manual);
+    }
+
+    [Fact]
+    public async Task Submit_herregistratie_with_zero_uren_is_afgewezen()
+    {
+        var a = await Create("herregistratie");
+        var res = await _client.PostAsJsonAsync($"/api/v1/applications/{a.Id}/submit", new { uren = 0 });
+        res.EnsureSuccessStatusCode();   // the submission is accepted...
+        var body = (await res.Content.ReadFromJsonAsync<SubmitApplicationResponse>())!;
+        Assert.Equal("Afgewezen", body.Status.Tag);   // ...but resolves to rejected
+        Assert.NotNull(body.Status.Reden);
+    }
+
+    [Fact]
+    public async Task Submitting_twice_conflicts()
+    {
+        var a = await Create("registratie");
+        (await _client.PostAsJsonAsync($"/api/v1/applications/{a.Id}/submit", new { diplomaHerkomst = "duo" })).EnsureSuccessStatusCode();
+        var again = await _client.PostAsJsonAsync($"/api/v1/applications/{a.Id}/submit", new { diplomaHerkomst = "duo" });
+        Assert.Equal(HttpStatusCode.Conflict, again.StatusCode);
+    }
+
+    [Fact]
+    public async Task Cancel_concept_removes_it()
+    {
+        var a = await Create();
+        Assert.Equal(HttpStatusCode.NoContent, (await _client.DeleteAsync($"/api/v1/applications/{a.Id}")).StatusCode);
+        Assert.Equal(HttpStatusCode.NotFound, (await _client.GetAsync($"/api/v1/applications/{a.Id}")).StatusCode);
+    }
+
+    [Fact]
+    public async Task Cancel_submitted_aanvraag_conflicts()
+    {
+        var a = await Create("registratie");
+        (await _client.PostAsJsonAsync($"/api/v1/applications/{a.Id}/submit", new { diplomaHerkomst = "duo" })).EnsureSuccessStatusCode();
+        Assert.Equal(HttpStatusCode.Conflict, (await _client.DeleteAsync($"/api/v1/applications/{a.Id}")).StatusCode);
+    }
+
+    // --- Auto-approval is computed on read: exercise the window boundary without waiting. ---
+
+    private static Aanvraag Accepted(bool autoApprovable) => new()
+    {
+        Id = "x", Type = "registratie", Owner = "test",
+        Submitted = true, AutoApprovable = autoApprovable, Referentie = "BIG-2026-1",
+        SubmittedAt = DateTimeOffset.UtcNow, CreatedAt = DateTimeOffset.UtcNow, UpdatedAt = DateTimeOffset.UtcNow,
+    };
+
+    [Fact]
+    public void AutoApprovable_flips_to_goedgekeurd_after_the_window()
+    {
+        var a = Accepted(autoApprovable: true);
+        var t0 = a.SubmittedAt!.Value;
+        Assert.Equal("InBehandeling", a.ToStatusDto(t0 + ApplicationStore.ProcessingWindow - TimeSpan.FromSeconds(1)).Tag);
+        Assert.Equal("Goedgekeurd", a.ToStatusDto(t0 + ApplicationStore.ProcessingWindow + TimeSpan.FromSeconds(1)).Tag);
+    }
+
+    [Fact]
+    public void Manual_case_never_auto_advances()
+    {
+        var a = Accepted(autoApprovable: false);
+        var far = a.SubmittedAt!.Value + ApplicationStore.ProcessingWindow + TimeSpan.FromDays(1);
+        var status = a.ToStatusDto(far);
+        Assert.Equal("InBehandeling", status.Tag);
+        Assert.True(status.Manual);
+    }
+}