Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 not
|
417f6abfa8 | ||
 notandClaude Opus 4.8
|
5de2e9367d |
+2
-24
@@ -199,25 +199,9 @@ _Split from the original S-09 — scoped to the portal only; the approval flow i
|
||||
|
||||
### S-10 · Document upload + boundary timer for document timeout (Flow 2)
|
||||
|
||||
Split (issue #11 closed) into two independently-demoable slices per §13 — the original spanned six net-new surfaces including a new ZGW boundary:
|
||||
**Outcome:** BPMN extended with a "wacht op documenten" user task with a 30-day boundary timer. Self-service portal supports diploma upload. On timeout the case is cancelled.
|
||||
|
||||
#### S-10a · Document-wait task + 30-day timeout cancellation + provision trigger — #102
|
||||
|
||||
**Outcome:** BPMN gains a `WachtOpDocumenten` user task with a 30-day (P30D) interrupting boundary timer. On timeout the case is cancelled — the timer runs to a dedicated cancel end-event and the domain aggregate moves to a new terminal status `Verlopen` via an external-worker (mirrors S-14 escalation / S-11 withdrawal). "Documents received" is wired end-to-end (domain endpoint + BFF + a "Documenten aanleveren" button on the self-service page) so the walking-skeleton e2e stays green — but the document is **not yet stored** in ZGW; that is S-10b.
|
||||
|
||||
**Acceptance:** BDD both branches (documents-in-time vs timeout-cancel); live timer-fire via the management-API "move" idiom; the registration e2e provides documents before the behandelaar step.
|
||||
|
||||
#### S-10b · Real diploma upload stored via the ACL Documenten API — #103
|
||||
|
||||
**Outcome:** the self-service "Documenten aanleveren" action becomes a real file upload; the file (base64-encoded end-to-end) is stored in the ZGW Documenten (DRC) API as an `enkelvoudiginformatieobject` and related to the zaak, with all document calls routed through the ACL (§8.1, ADR-0018). Builds on the S-10a trigger/wait. Depends on #102.
|
||||
|
||||
**Acceptance:** ACL Documenten gateway integration test (real OpenZaak); Playwright e2e uploads a real PDF.
|
||||
|
||||
#### S-10c · Close the ZGW zaak on document-timeout expiry — #106
|
||||
|
||||
**Outcome:** when the 30-day term lapses (S-10a `RegistratieVerlopen`), the ZGW zaak is set to a distinct non-terminal `Geannuleerd` status + `Vervallen` resultaat (not just the domain aggregate → `Verlopen`), resolved by name in the ACL. Adds the cancellation statustype/resultaattype to the seed + an ACL `CancelZaakAsync`/`POST /annuleringen` + expiry-worker wiring. Carved from S-10b (ADR-0017/0018/0019). Depends on #103.
|
||||
|
||||
**Acceptance:** ACL↔OpenZaak integration test (cancellation records `Geannuleerd` + a resultaat, live); the domain verify script fires the P30D timer and asserts the zaak reaches `Geannuleerd` end-to-end; BDD asserts the zaak is cancelled on timeout but untouched when documents arrive in time.
|
||||
**Acceptance:** BDD scenarios for both branches; integration tests for the timer firing.
|
||||
|
||||
### S-11 · Withdrawal (Flow 3)
|
||||
|
||||
@@ -239,12 +223,6 @@ Split (issue #11 closed) into two independently-demoable slices per §13 — the
|
||||
|
||||
**Outcome:** Boundary timer on beoordeling user task — 14 days. On timeout, reassigns to a teamlead role.
|
||||
|
||||
### S-26 · Self-service — resume an existing registration after refresh — #111
|
||||
|
||||
**Outcome:** a signed-in zorgprofessional who reloads the self-service portal (or returns later) gets back to their in-flight registration and its actions (Documenten aanleveren, Trek aanvraag in), instead of a blank submit form with the reference lost. Today all post-submit state lives in in-memory signals, the reference is not in the URL, and there is no self-service read endpoint — so a reload strands the registration. Adds an owner-scoped (DigiD bsn) `GET /self-service/registrations` on the BFF/domain and a load-on-init/route restore in the portal.
|
||||
|
||||
**Acceptance:** BDD — resume after refresh shows the existing registration; lookup is owner-scoped (never another citizen's); a user with no in-flight registration still sees the submit form. Playwright e2e reloads mid-flow and asserts the actions remain reachable.
|
||||
|
||||
---
|
||||
|
||||
## Iteration 3 — Maintenance portal and observability *(milestone: `Iteration 3 — Beheer & Observability`)*
|
||||
|
||||
@@ -43,7 +43,7 @@ export DOCKER_HOST := unix://$(PODMAN_SOCK)
|
||||
endif
|
||||
endif
|
||||
|
||||
.PHONY: ci lint build unit mutation frontend integration verify verify-up verify-acl verify-nrc verify-projection verify-bff verify-domain verify-notifications smoke up down local verify-local local-down changelog openzaak-up openzaak-smoke openzaak-seed openzaak-down stack-up stack-smoke stack-down keycloak-up keycloak-smoke keycloak-down flowable-up flowable-smoke flowable-down help
|
||||
.PHONY: ci lint build unit mutation frontend integration verify verify-up verify-acl verify-nrc verify-projection verify-bff verify-domain verify-notifications smoke up down local local-down changelog openzaak-up openzaak-smoke openzaak-seed openzaak-down stack-up stack-smoke stack-down keycloak-up keycloak-smoke keycloak-down flowable-up flowable-smoke flowable-down help
|
||||
|
||||
## ci: run the full pipeline — lint, build, unit, mutation, frontend, verify (mirrors Gitea Actions)
|
||||
## `verify` is the live-stack stage (full stack up once → ACL + notification checks).
|
||||
@@ -114,11 +114,6 @@ local:
|
||||
docker compose -f $(LOCAL_COMPOSE) up -d --build
|
||||
WAIT_TIMEOUT=420 bash infra/wait-healthy.sh $(WAIT_SVCS)
|
||||
|
||||
## verify-local: acceptance check for the local stack (S-B04) — a fresh `make local` completes the
|
||||
## whole flow (zaaktype seeded + DMN deployed + NRC abonnement) with NO manual seeding.
|
||||
verify-local:
|
||||
bash infra/run-local-flow-check.sh
|
||||
|
||||
## local-down: stop and remove the bind-mount stack
|
||||
local-down:
|
||||
docker compose -f $(LOCAL_COMPOSE) down --volumes
|
||||
|
||||
@@ -11,33 +11,6 @@
|
||||
<p utrecht-paragraph role="status">
|
||||
Uw registratie is ontvangen. Referentie: {{ reference() }}.
|
||||
</p>
|
||||
@if (documentsProvided()) {
|
||||
<p utrecht-paragraph role="status">Uw documenten zijn aangeleverd.</p>
|
||||
} @else {
|
||||
@if (provideDocumentsFailed()) {
|
||||
<p utrecht-paragraph role="alert">
|
||||
Het aanleveren van uw documenten is niet gelukt. Probeer het opnieuw.
|
||||
</p>
|
||||
}
|
||||
<p utrecht-paragraph>Lever uw diploma aan (PDF).</p>
|
||||
<label utrecht-form-label for="diploma">Diploma</label>
|
||||
<input
|
||||
id="diploma"
|
||||
type="file"
|
||||
accept="application/pdf"
|
||||
[disabled]="providingDocuments()"
|
||||
(change)="onFileSelected($event)"
|
||||
/>
|
||||
<button
|
||||
utrecht-button
|
||||
appearance="primary-action-button"
|
||||
type="button"
|
||||
[disabled]="providingDocuments() || !selectedFile()"
|
||||
(click)="provideDocuments()"
|
||||
>
|
||||
Documenten aanleveren
|
||||
</button>
|
||||
}
|
||||
@if (withdrawFailed()) {
|
||||
<p utrecht-paragraph role="alert">
|
||||
Het intrekken van uw registratie is niet gelukt. Probeer het opnieuw.
|
||||
|
||||
@@ -20,24 +20,17 @@ class FakeAuth extends AuthService {
|
||||
function providers(
|
||||
post = vi.fn().mockReturnValue(of({ registrationId: 'reg-9', status: 'Ingediend' })),
|
||||
withdraw = vi.fn().mockReturnValue(of(undefined)),
|
||||
provideDocuments = vi.fn().mockReturnValue(of(undefined)),
|
||||
// Resume lookup (S-26): default to 204/empty — no in-flight registration, so the submit form shows.
|
||||
getCurrent = vi.fn().mockReturnValue(of(undefined)),
|
||||
) {
|
||||
return {
|
||||
post,
|
||||
withdraw,
|
||||
provideDocuments,
|
||||
getCurrent,
|
||||
providers: [
|
||||
{ provide: AuthService, useClass: FakeAuth },
|
||||
{
|
||||
provide: BffApiV1Service,
|
||||
useValue: {
|
||||
getSelfServiceRegistrations: getCurrent,
|
||||
postSelfServiceRegistrations: post,
|
||||
postSelfServiceRegistrationsIdWithdraw: withdraw,
|
||||
postSelfServiceRegistrationsIdDocuments: provideDocuments,
|
||||
},
|
||||
},
|
||||
],
|
||||
@@ -60,21 +53,6 @@ describe('RegistrationPage', () => {
|
||||
expect(await screen.findByText(/ontvangen/i)).toBeTruthy();
|
||||
});
|
||||
|
||||
it('resumes an existing registration on load, without submitting again (S-26)', async () => {
|
||||
const { post, providers: p } = providers(
|
||||
undefined,
|
||||
undefined,
|
||||
undefined,
|
||||
vi.fn().mockReturnValue(of({ registrationId: 'reg-77', status: 'Ingediend' })),
|
||||
);
|
||||
await render(RegistrationPage, { providers: p });
|
||||
|
||||
// The confirmation view is restored from the in-flight registration — no submit click.
|
||||
expect(await screen.findByText(/ontvangen/i)).toBeTruthy();
|
||||
expect(screen.getByText(/reg-77/)).toBeTruthy();
|
||||
expect(post).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it('shows an error and keeps the submit available when the BFF call fails', async () => {
|
||||
const { post, providers: p } = providers(vi.fn().mockReturnValue(throwError(() => new Error('BFF rejected'))));
|
||||
await render(RegistrationPage, { providers: p });
|
||||
@@ -102,46 +80,6 @@ describe('RegistrationPage', () => {
|
||||
expect(await screen.findByText(/ingetrokken/i)).toBeTruthy();
|
||||
});
|
||||
|
||||
// A small PDF file the citizen "uploads"; the component base64-encodes it client-side.
|
||||
const diploma = () => new File([new Uint8Array([1, 2, 3])], 'diploma.pdf', { type: 'application/pdf' });
|
||||
|
||||
it('uploads a chosen diploma after submitting, and doing so confirms', async () => {
|
||||
const { provideDocuments, providers: p } = providers();
|
||||
await render(RegistrationPage, { providers: p });
|
||||
|
||||
fireEvent.click(screen.getByRole('button', { name: /indienen/i }));
|
||||
await screen.findByText(/ontvangen/i);
|
||||
|
||||
// Choose the file, then upload it.
|
||||
fireEvent.change(screen.getByLabelText(/diploma/i), { target: { files: [diploma()] } });
|
||||
fireEvent.click(await screen.findByRole('button', { name: /documenten aanleveren/i }));
|
||||
|
||||
// The upload is keyed by the reference and carries the base64 file + its name; the page confirms.
|
||||
expect(await screen.findByText(/documenten.*aangeleverd/i)).toBeTruthy();
|
||||
expect(provideDocuments).toHaveBeenCalledWith(
|
||||
'reg-9',
|
||||
expect.objectContaining({ fileName: 'diploma.pdf', contentType: 'application/pdf', contentBase64: expect.any(String) }),
|
||||
);
|
||||
});
|
||||
|
||||
it('surfaces a diploma-upload failure and keeps the action available', async () => {
|
||||
const { providers: p } = providers(
|
||||
vi.fn().mockReturnValue(of({ registrationId: 'reg-9', status: 'Ingediend' })),
|
||||
vi.fn().mockReturnValue(of(undefined)),
|
||||
vi.fn().mockReturnValue(throwError(() => new Error('documents rejected'))),
|
||||
);
|
||||
await render(RegistrationPage, { providers: p });
|
||||
|
||||
fireEvent.click(screen.getByRole('button', { name: /indienen/i }));
|
||||
await screen.findByText(/ontvangen/i);
|
||||
fireEvent.change(screen.getByLabelText(/diploma/i), { target: { files: [diploma()] } });
|
||||
fireEvent.click(await screen.findByRole('button', { name: /documenten aanleveren/i }));
|
||||
|
||||
expect(await screen.findByRole('alert')).toBeTruthy();
|
||||
expect(screen.queryByText(/aangeleverd/i)).toBeNull();
|
||||
expect(screen.getByRole('button', { name: /documenten aanleveren/i })).toBeTruthy();
|
||||
});
|
||||
|
||||
it('surfaces a withdraw failure and keeps the action available', async () => {
|
||||
const { providers: p } = providers(
|
||||
vi.fn().mockReturnValue(of({ registrationId: 'reg-9', status: 'Ingediend' })),
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { Component, inject, type OnInit, signal } from '@angular/core';
|
||||
import { BffApiV1Service, type CurrentRegistration, type SubmitAccepted } from 'api-client';
|
||||
import { Component, inject, signal } from '@angular/core';
|
||||
import { BffApiV1Service, type SubmitAccepted } from 'api-client';
|
||||
import { AuthService } from 'auth';
|
||||
import { UtrechtComponentsModule } from 'ui';
|
||||
|
||||
@@ -8,16 +8,13 @@ import { UtrechtComponentsModule } from 'ui';
|
||||
* registration. The bsn comes from the DigiD token (not a form field), so this is a confirm-and-
|
||||
* submit flow that posts to the BFF and shows the returned reference (ADR-0010; S-08c). After
|
||||
* submitting they can withdraw it — "trek aanvraag in" — keyed by that reference (S-11c).
|
||||
*
|
||||
* On load it asks the BFF for the caller's current open registration and restores the submitted view
|
||||
* if there is one, so a page refresh no longer strands an in-flight registration (S-26).
|
||||
*/
|
||||
@Component({
|
||||
selector: 'app-registration-page',
|
||||
imports: [UtrechtComponentsModule],
|
||||
templateUrl: './registration-page.html',
|
||||
})
|
||||
export class RegistrationPage implements OnInit {
|
||||
export class RegistrationPage {
|
||||
private readonly auth = inject(AuthService);
|
||||
private readonly bff = inject(BffApiV1Service);
|
||||
|
||||
@@ -29,27 +26,6 @@ export class RegistrationPage implements OnInit {
|
||||
protected readonly withdrawing = signal(false);
|
||||
protected readonly withdrawn = signal(false);
|
||||
protected readonly withdrawFailed = signal(false);
|
||||
protected readonly providingDocuments = signal(false);
|
||||
protected readonly documentsProvided = signal(false);
|
||||
protected readonly provideDocumentsFailed = signal(false);
|
||||
protected readonly selectedFile = signal<File | undefined>(undefined);
|
||||
|
||||
/** Resume an existing in-flight registration after a refresh (S-26): the BFF returns the caller's
|
||||
* current open registration, or 204 (empty body) when there is none — in which case we show the
|
||||
* submit form as before. Failures are non-fatal for the same reason. */
|
||||
ngOnInit(): void {
|
||||
this.bff.getSelfServiceRegistrations().subscribe({
|
||||
next: (current: CurrentRegistration | void) => {
|
||||
if (current && current.registrationId) {
|
||||
this.reference.set(current.registrationId);
|
||||
this.submitted.set(true);
|
||||
}
|
||||
},
|
||||
error: () => {
|
||||
// No resumable registration (or the lookup failed) — fall back to the submit form.
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
submit(): void {
|
||||
this.submitting.set(true);
|
||||
@@ -68,46 +44,6 @@ export class RegistrationPage implements OnInit {
|
||||
});
|
||||
}
|
||||
|
||||
onFileSelected(event: Event): void {
|
||||
const input = event.target as HTMLInputElement;
|
||||
this.selectedFile.set(input.files?.[0] ?? undefined);
|
||||
}
|
||||
|
||||
async provideDocuments(): Promise<void> {
|
||||
const reference = this.reference();
|
||||
const file = this.selectedFile();
|
||||
if (!reference || !file) {
|
||||
return;
|
||||
}
|
||||
this.providingDocuments.set(true);
|
||||
this.provideDocumentsFailed.set(false);
|
||||
let contentBase64: string;
|
||||
try {
|
||||
contentBase64 = await readAsBase64(file);
|
||||
} catch {
|
||||
this.provideDocumentsFailed.set(true);
|
||||
this.providingDocuments.set(false);
|
||||
return;
|
||||
}
|
||||
this.bff
|
||||
.postSelfServiceRegistrationsIdDocuments(reference, {
|
||||
contentBase64,
|
||||
fileName: file.name,
|
||||
contentType: file.type || 'application/pdf',
|
||||
})
|
||||
.subscribe({
|
||||
next: () => {
|
||||
this.documentsProvided.set(true);
|
||||
this.providingDocuments.set(false);
|
||||
},
|
||||
// Surface the failure instead of swallowing it: keep the action so the user can retry.
|
||||
error: () => {
|
||||
this.provideDocumentsFailed.set(true);
|
||||
this.providingDocuments.set(false);
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
withdraw(): void {
|
||||
const reference = this.reference();
|
||||
if (!reference) {
|
||||
@@ -128,13 +64,3 @@ export class RegistrationPage implements OnInit {
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/** Read a file's bytes as a base64 string (without the `data:...;base64,` prefix). */
|
||||
function readAsBase64(file: File): Promise<string> {
|
||||
return new Promise<string>((resolve, reject) => {
|
||||
const reader = new FileReader();
|
||||
reader.onload = () => resolve(((reader.result as string) ?? '').split(',', 2)[1] ?? '');
|
||||
reader.onerror = () => reject(reader.error ?? new Error('Could not read the file.'));
|
||||
reader.readAsDataURL(file);
|
||||
});
|
||||
}
|
||||
|
||||
@@ -1,77 +0,0 @@
|
||||
# ADR-0015: Beoordeling escalation reassigns via an external-worker task
|
||||
|
||||
- **Status:** Accepted
|
||||
- **Date:** 2026-07-17
|
||||
- **Deciders:** Respellion engineering
|
||||
- **Relates to:** S-14 (#15); proposal #98. Builds on ADR-0009 (external-task worker / Workflow
|
||||
Client), ADR-0013 (behandel-portal wiring, the `Beoordelen` user task), ADR-0014 (the boundary-event
|
||||
pattern on `Beoordelen`).
|
||||
|
||||
## Context
|
||||
|
||||
S-14 escalates a beoordeling that a behandelaar does not pick up in time: after 14 days the case must
|
||||
move to the `teamlead` role (PRD §5, flow 5). The `Beoordelen` user task already exists, claimable by
|
||||
the `behandelaar` candidate group; the teamlead role is seeded in the medewerker realm.
|
||||
|
||||
Two forces shape this.
|
||||
|
||||
1. **The task must stay open.** Escalation changes *who may claim* an unclaimed beoordeling, not the
|
||||
work itself — so the timer must be **non-interrupting**: the `Beoordelen` task keeps running while
|
||||
escalation happens alongside it.
|
||||
2. **Reassigning an open task's candidate group needs code.** Flowable cannot rewrite the candidate
|
||||
groups of an already-open user task from BPMN XML alone — that requires either a Java delegate/listener
|
||||
embedded in the engine, or an out-of-process actor driving the REST API. The repository has held a
|
||||
"stock Flowable image, no custom jars; the Workflow Client is the only code that talks to Flowable
|
||||
(§8.2)" posture since ADR-0009.
|
||||
|
||||
## Decision
|
||||
|
||||
**A non-interrupting `P14D` boundary timer on `Beoordelen` fires an external-worker task
|
||||
(`BeoordelingEscaleren`); the Workflow Client reassigns the still-open `Beoordelen` task from the
|
||||
behandelaar group to teamlead.**
|
||||
|
||||
- **Modelled in BPMN, driven by an external worker.** The timer routes a parallel token to an
|
||||
`external-worker` service task on the `BeoordelingEscaleren` topic, ending at a dedicated "Beoordeling
|
||||
geëscaleerd" end event. The model owns *when* escalation happens; the Workflow Client — the only code
|
||||
that talks to Flowable (§8.2) — owns *how* the reassignment is applied, exactly as `OpenZaakAanmaken`
|
||||
delegates the ZGW call (ADR-0009). No custom code runs inside Flowable.
|
||||
- **Reassignment is a candidate-group swap.** The escalation worker finds the still-open `Beoordelen`
|
||||
task in the escalating instance (task query by `processInstanceId` + `taskDefinitionKey`), adds
|
||||
`teamlead` as a candidate group via the task identity links, then removes `behandelaar`. The task now
|
||||
belongs to the teamlead; its history and variables are untouched.
|
||||
- **Best-effort, mirroring beoordeling and withdrawal.** If the task is no longer open — the behandelaar
|
||||
completed it in the window before the timer fired — the reassignment is a no-op. A failed reassignment
|
||||
leaves the escalation job un-completed so Flowable redelivers it (§8.6), consistent with the
|
||||
`OpenZaakAanmaken` worker.
|
||||
- **Segregated interface.** The escalation methods live on `IBeoordelingEscalatieClient`, separate from
|
||||
the `OpenZaakAanmaken` worker's `IExternalWorkerClient`, so the OpenZaak worker never sees escalation
|
||||
(interface segregation). Both are implemented by the one `FlowableWorkflowClient`.
|
||||
|
||||
## Consequences
|
||||
|
||||
**Positive**
|
||||
|
||||
- The escalation trigger is visible in `registratie.bpmn`; Flowable stays a stock image, and the
|
||||
Workflow Client remains the sole Flowable client (§8.2 upheld, not bent).
|
||||
- Reuses the external-worker mechanics (topic acquire/complete, hosted pump, per-tick scope,
|
||||
redelivery-on-failure) wholesale — the new code is one client capability, one processor, one pump.
|
||||
- Escalation latency is bounded by the worker's poll interval (seconds) — negligible against a 14-day
|
||||
timer.
|
||||
|
||||
**Negative / costs**
|
||||
|
||||
- Escalation is two REST hops (add teamlead, remove behandelaar) rather than one atomic update; between
|
||||
them the task is briefly claimable by both groups. Harmless at these volumes, and the pair is idempotent
|
||||
on redelivery.
|
||||
- The Flowable identity-link and management-job REST shapes are validated live (verify-domain fires the
|
||||
timer early via the management API), not in the Workflow Client's unit tests, which stub the HTTP
|
||||
exchange and assert only the request shape — consistent with ADR-0009 and ADR-0014.
|
||||
|
||||
## Alternatives considered
|
||||
|
||||
- **Flowable timer/task listener (Java delegate).** Reassign in-engine when the timer fires. Rejected:
|
||||
it needs a custom jar in Flowable, breaking the stock-image, REST-only posture and adding a build/deploy
|
||||
surface to the engine for no capability the external-worker route lacks.
|
||||
- **Interrupting timer that re-creates the task for teamlead.** Cancel `Beoordelen` and start a fresh
|
||||
teamlead task. Rejected: it loses the task's identity/history and complicates correlation, where a
|
||||
candidate-group swap on the same task expresses "the same work, now the teamlead's" directly.
|
||||
@@ -1,77 +0,0 @@
|
||||
# ADR-0016: Diploma eligibility is a DMN evaluated inline as a BPMN DMN service task
|
||||
|
||||
- **Status:** Accepted
|
||||
- **Date:** 2026-07-17
|
||||
- **Deciders:** Respellion engineering
|
||||
- **Relates to:** S-13 (#14); proposal #100. Builds on ADR-0009 (external-task worker / Workflow
|
||||
Client), ADR-0014/0015 (the boundary-event and routing constructs on the registratie process).
|
||||
|
||||
## Context
|
||||
|
||||
S-13 adds flow 4: a foreign diploma must get an extra CBGV-advies assessment before beoordeling
|
||||
(PRD §5). The eligibility decision — domestic goes straight to beoordeling, foreign routes through
|
||||
CBGV-advies — needs a home. The Flowable REST app bundles a DMN engine, and the same
|
||||
`repository/deployments` machinery that deploys `registratie.bpmn` can deploy a `.dmn`. §8.2 makes
|
||||
the Workflow Client the only code that talks to Flowable; the PRD frames the workflow as "BPMN + DMN
|
||||
governing the registration workflow" (Flowable as a peer orchestration module).
|
||||
|
||||
The issue's wording ("a DMN decision table evaluated by the Domain Service via Workflow Client")
|
||||
suggests the domain reaches into Flowable's DMN API to evaluate the decision and feeds the result
|
||||
back. That is one option; it is not the only one, and it is not the cleanest.
|
||||
|
||||
## Decision
|
||||
|
||||
**The diploma-eligibility DMN is deployed to Flowable and evaluated inline by the registratie process
|
||||
as a DMN service task (`flowable:type="dmn"`); an exclusive gateway routes on its output. The domain's
|
||||
only new job is to carry the diploma origin and pass it into the process as a start variable.**
|
||||
|
||||
- **The decision lives in the workflow.** `workflows/diploma-eligibility.dmn` maps `diplomaOrigin`
|
||||
→ `route` (`Buitenlands` ⇒ `CBGV_ADVIES`, otherwise `DIRECT`). A DMN service task
|
||||
(`flowable:type="dmn"`, `decisionTableReferenceKey=diploma-eligibility`) runs it between
|
||||
`OpenZaakAanmaken` and `Beoordelen`, and an exclusive gateway sends `CBGV_ADVIES` through a new
|
||||
`CBGVAdvies` user task before `Beoordelen`, `DIRECT` straight there. (A `businessRuleTask` would
|
||||
bind Flowable's legacy Drools/KIE implementation, which `flowable-rest` does not bundle — its parse
|
||||
handler throws `NoClassDefFoundError` at deploy time; the DMN service task is the supported route.)
|
||||
- **The domain carries the input, not the decision.** The `Registration` aggregate gains a
|
||||
`DiplomaOrigin` (Binnenlands/Buitenlands); `SubmitRegistration` passes it to
|
||||
`StartRegistrationProcessAsync`, which sets it as the `diplomaOrigin` start variable. The domain
|
||||
never evaluates the DMN and never learns the route — that is the process's concern.
|
||||
- **Deployed as its own DMN-engine deployment, separate from the BPMN.** The DMN is version-controlled
|
||||
in `workflows/` and `flowable-init` deploys it to the DMN engine via the `dmn-api`
|
||||
(`/dmn-api/dmn-repository/deployments`), while `registratie.bpmn` goes to the process engine via
|
||||
`/service/repository/deployments`. Two things were learned the hard way here (both cost a CI cycle):
|
||||
(1) `flowable-rest` does **not** cascade a `.dmn` bundled inside a process `.bar` into the DMN engine
|
||||
— the resource is stored but no decision is created, so the service task fails at runtime with
|
||||
`FlowableObjectNotFoundException: No decision found for key`; the DMN must go through `dmn-api`.
|
||||
(2) Flowable's DMN XML converter rejects an XML comment placed between the `<?xml?>` declaration and
|
||||
the root `<definitions>` element (`XMLStreamReader not in START_DOCUMENT or START_ELEMENT state`),
|
||||
unlike its BPMN converter — so the DMN's documentation comment lives *inside* `<definitions>`.
|
||||
With the decision present in the DMN repository, the process's DMN service task resolves it across
|
||||
deployments by key (verified live), so no shared parent deployment id is needed.
|
||||
|
||||
## Consequences
|
||||
|
||||
**Positive**
|
||||
|
||||
- The eligibility rule is a first-class, inspectable workflow artefact (matching the PRD's BPMN+DMN
|
||||
framing); business users can read/adjust the decision table without touching domain code.
|
||||
- §8.2 stays clean: the Workflow Client remains the only code talking to Flowable, and the decision
|
||||
runs inside the process the client already started — no domain→Flowable round-trip for a decision.
|
||||
- The domain change is minimal and additive: one value on the aggregate, one start variable.
|
||||
|
||||
**Negative / costs**
|
||||
|
||||
- Deviates from #14's literal "evaluated by the Domain Service via Workflow Client" wording (noted on
|
||||
the issue). The outcome — DMN decides eligibility, foreign diplomas get the CBGV step — is unchanged.
|
||||
- The DMN and its service-task wiring are validated live (verify-domain drives a foreign
|
||||
registration through CBGV-advies and a domestic one straight to beoordeling, exercising both
|
||||
branches), not in unit tests — consistent with ADR-0009/0014/0015. The domain unit/acceptance tests
|
||||
cover only that the origin is carried into the process.
|
||||
|
||||
## Alternatives considered
|
||||
|
||||
- **Domain evaluates the DMN via the Workflow Client** (the issue's wording). Rejected: it couples
|
||||
the domain to Flowable for a decision and splits the routing across two places (domain computes,
|
||||
BPMN branches), for no benefit over letting the engine that owns the process own the decision.
|
||||
- **Eligibility rules in domain C#.** Rejected: it moves a governable business decision out of the
|
||||
DMN the PRD calls for, and hard-codes what the reference app is meant to demonstrate as data.
|
||||
@@ -1,90 +0,0 @@
|
||||
# ADR-0017: A document-wait task with a 30-day interrupting timer cancels the registration
|
||||
|
||||
- **Status:** Accepted
|
||||
- **Date:** 2026-07-20
|
||||
- **Deciders:** Respellion engineering
|
||||
- **Relates to:** S-10a (#102); proposal #104; split from S-10 (#11). Builds on ADR-0009 (external-task
|
||||
worker / Workflow Client), ADR-0014 (withdrawal cancels the process), ADR-0015 (beoordeling
|
||||
escalation — the boundary-timer + external-worker pattern), ADR-0016 (diploma-eligibility DMN).
|
||||
|
||||
## Context
|
||||
|
||||
Flow 2 (PRD §5) requires the citizen to supply documents (their diploma) after submitting. The
|
||||
registratie process must park waiting for those documents and, if they do not arrive within 30 days,
|
||||
cancel the case. S-10 was split (§13): **S-10a** is this workflow/timeout spine (backend only);
|
||||
**S-10b** wires the actual upload (portal → BFF → domain → ACL → Documenten API) that completes the
|
||||
wait. This ADR records the spine: where the wait sits, how the timeout cancels, and how the domain
|
||||
aggregate stays in sync.
|
||||
|
||||
## Decision
|
||||
|
||||
**A `WachtOpDocumenten` user task is inserted immediately after `OpenZaakAanmaken`, carrying an
|
||||
`cancelActivity="true"` (interrupting) `P30D` boundary timer. "Documents received" completes the task
|
||||
and the process continues into the diploma-eligibility routing; on timeout the timer cancels the task,
|
||||
runs a `RegistratieVerlopen` external-worker task, and ends the process at `endVerlopen`. A domain
|
||||
worker expires the correlated aggregate to a new terminal status `Verlopen`.**
|
||||
|
||||
- **Where the wait sits.** Right after the zaak is opened, before the diploma-eligibility DMN: the zaak
|
||||
exists, then the process waits for documents; on receipt it continues to the DMN routing → Beoordelen
|
||||
(ADR-0016). The wait gates the whole assessment, so it precedes the routing rather than sitting
|
||||
between the gateway and Beoordelen.
|
||||
- **Interrupting timer, mirroring the existing constructs.** Unlike the S-14 escalation timer
|
||||
(non-interrupting — the Beoordelen task stays open), this timer is interrupting: when it fires the
|
||||
wait token is consumed and the case is cancelled, like the S-11 withdrawal boundary (ADR-0014). The
|
||||
timeout branch runs a `RegistratieVerlopen` external-worker task (topic mirrors
|
||||
`OpenZaakAanmaken`/`BeoordelingEscaleren`) → `endVerlopen`.
|
||||
- **The domain stays authoritative.** The `RegistratieVerlopen` job carries the `registrationId`; the
|
||||
`RegistratieVerlopenProcessor` drains it and the `ExpireRegistrationWorker` loads the aggregate and
|
||||
calls `Registration.Expire()`, moving it to the new terminal status `Verlopen`. This keeps the
|
||||
aggregate — which the projection/openbaar view reads — the source of truth, exactly as escalation and
|
||||
withdrawal do. Idempotent per §8.6: a redelivered job whose aggregate is already `Verlopen` completes
|
||||
without persisting again; an unknown registration throws so the job is redelivered.
|
||||
- **Documents-in-time transition.** `IWorkflowClient.CompleteDocumentWaitAsync(processInstanceId)`
|
||||
completes the `WachtOpDocumenten` task (the Workflow Client remains the only code that talks to
|
||||
Flowable, §8.2). It is best-effort — a no-op if the instance already left the wait (continued, or
|
||||
timed out). The trigger is wired end-to-end in S-10a: a `ProvideDocuments` application use case behind
|
||||
an owner-scoped domain endpoint `POST /registrations/{id}/documents`, a BFF passthrough
|
||||
`POST /self-service/registrations/{id}/documents` (bsn from the DigiD token), and a "Documenten
|
||||
aanleveren" action on the self-service page — so the walking-skeleton e2e stays green (a registration
|
||||
can still reach the behandelaar). **S-10b replaces the stub trigger with a real file upload stored in
|
||||
the ZGW Documenten (DRC) API via the ACL**; the completion of the wait is unchanged.
|
||||
- *Why the trigger lives here, not in S-10b:* inserting the `WachtOpDocumenten` gate without any way
|
||||
to pass it breaks the submit→beoordeling e2e (a merge gate). Splitting "gate" from "means to pass
|
||||
the gate" across slices would leave `main` red, so S-10a owns both; S-10b is purely the ZGW storage
|
||||
behind the same action.
|
||||
|
||||
## Consequences
|
||||
|
||||
**Positive**
|
||||
|
||||
- The wait/timeout is a first-class workflow construct that reuses the boundary-timer + external-worker
|
||||
pattern already proven by S-14, so the domain change is small and additive: one terminal status, one
|
||||
worker trio (worker + processor + pump), one Workflow Client method.
|
||||
- §8 stays clean: the Workflow Client is still the only Flowable caller, and no new ZGW boundary is
|
||||
introduced in S-10a.
|
||||
- The timeout is verified live (verify-domain fires the P30D timer via the management-API "move" idiom
|
||||
and asserts the domain reaches `Verlopen`), consistent with ADR-0009/0014/0015.
|
||||
|
||||
**Negative / costs**
|
||||
|
||||
- Every registration now parks at `WachtOpDocumenten` before Beoordelen, so the other flows must supply
|
||||
documents first: the live-check blocks (S-11/S-12b/S-13/S-14) complete the task via Flowable, and the
|
||||
registration e2e clicks "Documenten aanleveren". A small, explicit step, but it touches every path
|
||||
through the process.
|
||||
- On expiry S-10a cancels the *process* and marks the aggregate `Verlopen` but does **not** set the ZGW
|
||||
*zaak* to a cancellation status — that needs a new ACL method + statustype seeding, which overlaps
|
||||
S-10b's ACL/infra work. Deferred to S-10b (or a follow-up); noted here as the S-10a/S-10b boundary.
|
||||
- Withdrawing while parked at `WachtOpDocumenten` marks the aggregate `Ingetrokken` but does not cancel
|
||||
the process (the withdrawal message boundary is on `Beoordelen`); the timeout worker tolerates this
|
||||
by no-op'ing on an already-resolved aggregate. Extending withdrawal to the wait state is a follow-up.
|
||||
|
||||
## Alternatives considered
|
||||
|
||||
- **Pure-BPMN cancellation (timer → end event, no worker).** Rejected: the domain aggregate would then
|
||||
be out of sync with the cancelled process, and the openbaar/projection view reads the aggregate's
|
||||
status — the case would still look open.
|
||||
- **Wait task between the gateway and Beoordelen.** Rejected: documents gate the whole assessment
|
||||
(including the CBGV-advies routing), so the wait belongs before the DMN, not after it.
|
||||
- **A dedicated timeout status per branch vs. reusing an open-state guard.** `Expire()` reuses the same
|
||||
`RequireOpenForDecision` guard as withdrawal/decision, so only an `INGEDIEND`/`IN_BEHANDELING`
|
||||
registration can lapse and the terminal states stay mutually exclusive — no new guard logic.
|
||||
@@ -1,74 +0,0 @@
|
||||
# ADR-0018: Diploma upload is stored in the ZGW Documenten API, fronted by the ACL
|
||||
|
||||
- **Status:** Accepted
|
||||
- **Date:** 2026-07-20
|
||||
- **Deciders:** Respellion engineering
|
||||
- **Relates to:** S-10b (#103); proposal #107. Builds on ADR-0001 (ACL is the only ZGW caller),
|
||||
ADR-0003 (ACL default-fill), ADR-0017 (document-wait + provision trigger). Carves the zaak-close on
|
||||
expiry to #106 (S-10c).
|
||||
|
||||
## Context
|
||||
|
||||
S-10a wired the "documenten aanleveren" trigger (portal → BFF → domain → complete the WachtOpDocumenten
|
||||
wait) with the file itself stubbed. S-10b makes the upload real: the diploma must be **stored in the
|
||||
ZGW Documenten (DRC) API** and related to the zaak. §8.1 makes the ACL the only code that talks to ZGW.
|
||||
The DRC API is served by the same OpenZaak container as the Zaken/Catalogi APIs.
|
||||
|
||||
## Decision
|
||||
|
||||
**The ACL fronts the Documenten API: it creates an `enkelvoudiginformatieobject` and relates it to the
|
||||
zaak. The file travels base64-encoded in JSON across every hop (the portal encodes it client-side); a
|
||||
"Diploma" `informatieobjecttype` is seeded in the catalogus and injected into the ACL like the
|
||||
zaaktype.**
|
||||
|
||||
- **ACL gateway.** `OpenZaakGateway.StoreDocumentAsync` POSTs the `enkelvoudiginformatieobject`
|
||||
(`/documenten/api/v1/enkelvoudiginformatieobjecten`, base64 `inhoud`, `bestandsomvang`,
|
||||
`status=definitief`) then relates it to the zaak (`/zaken/api/v1/zaakinformatieobjecten`), reusing the
|
||||
established gateway patterns (ZGW Bearer JWT, buffered non-chunked body for uwsgi, **no CRS headers** —
|
||||
the Documenten API is not geo, unlike zaak-create). `AclService.StoreDiplomaAsync` default-fills the
|
||||
ZGW-mandatory fields (informatieobjecttype, bronorganisatie, vertrouwelijkheidaanduiding, `taal=nld`,
|
||||
creatiedatum); the domain hands over only the zaak, the bytes, and the file's name/type. No new ZGW
|
||||
scopes were needed — the seed applicatie holds `heeft_alle_autorisaties`.
|
||||
- **The file travels as base64 JSON end-to-end.** The portal reads the chosen file client-side
|
||||
(`FileReader`) and posts `{ contentBase64, fileName, contentType }` as JSON to the BFF; the BFF
|
||||
forwards it to the domain, and the domain to the ACL, all as JSON. This deviates from proposal #107's
|
||||
"multipart on the portal→BFF hop": base64 JSON keeps **one** contract shape across all four services
|
||||
(no `IFormFile`/antiforgery plumbing, no multipart in the generated client), and a diploma is a small
|
||||
placeholder PDF, so the ~33% base64 overhead is immaterial. The ACL turns the base64 back into the
|
||||
ZGW `inhoud`.
|
||||
- **Storing precedes completing the wait.** `ProvideDocuments` (from S-10a) now stores the diploma via
|
||||
the ACL — once the zaak is opened — and then completes the `WachtOpDocumenten` task, so a registration
|
||||
reaches beoordeling only after its diploma is stored. Both steps stay best-effort about missing
|
||||
preconditions (no zaak yet → skip storage; no process yet → skip completion), mirroring withdrawal.
|
||||
- **Catalogus.** `seed_catalogus.py` (OZ_PUBLISH) creates a "Diploma" `informatieobjecttype`, relates it
|
||||
to the zaaktype (`zaaktype-informatieobjecttypen`, while both concept), publishes both, and prints
|
||||
`INFORMATIEOBJECTTYPE_URL`; verify-domain injects it as `Acl__Defaults__InformatieobjecttypeUrl`
|
||||
(a zeros-uuid placeholder otherwise, so the ACL still boots).
|
||||
|
||||
## Consequences
|
||||
|
||||
**Positive**
|
||||
|
||||
- §8.1 stays intact: the ACL is still the only ZGW caller; the portal only talks to the BFF; the domain
|
||||
only crosses the ACL boundary. Adding a document was almost entirely additive (one gateway method, one
|
||||
default, one seed block).
|
||||
- One JSON contract shape across portal/BFF/domain/ACL keeps the generated client and the service
|
||||
contracts uniform; the upload is exercised live (ACL integration test against real OpenZaak; the
|
||||
Playwright journey uploads a real PDF).
|
||||
|
||||
**Negative / costs**
|
||||
|
||||
- Base64 inflates the payload ~33% and holds the whole file in memory at each hop — fine for a small
|
||||
diploma, but not a pattern to reuse for large documents without streaming/multipart.
|
||||
- The zaak is **not** set to a cancellation status when the 30-day term lapses — carved to #106 (S-10c),
|
||||
which adds the cancellation statustype/resultaattype + ACL method + expiry-worker wiring.
|
||||
- Providing documents before the zaak is opened silently skips storage (best-effort); the e2e/live flow
|
||||
avoids this by uploading only after the openbaar register shows the zaak (INGEDIEND).
|
||||
|
||||
## Alternatives considered
|
||||
|
||||
- **Multipart on the portal→BFF hop** (proposal #107). Rejected: it splits the transport into two shapes
|
||||
(multipart then JSON), needs `IFormFile` + antiforgery handling and a multipart method in the generated
|
||||
client, for no benefit at diploma size.
|
||||
- **The domain talks to the Documenten API directly.** Rejected outright: violates §8.1 (only the ACL
|
||||
talks to ZGW).
|
||||
@@ -1,81 +0,0 @@
|
||||
# ADR-0019: A timed-out zaak is cancelled with a distinct status + resultaat, resolved by name
|
||||
|
||||
- **Status:** Accepted
|
||||
- **Date:** 2026-07-21
|
||||
- **Deciders:** Respellion engineering
|
||||
- **Relates to:** S-10c (#106). Completes the S-10a/S-10b boundary noted in ADR-0017 (§Consequences) and
|
||||
reuses the ACL close-zaak machinery from S-09b (approval) and the Documenten work in ADR-0018.
|
||||
|
||||
## Context
|
||||
|
||||
ADR-0017 (S-10a) cancels the *process* and marks the domain aggregate `Verlopen` when the 30-day
|
||||
document term lapses, but explicitly deferred setting the ZGW **zaak** to a cancellation status. Left
|
||||
open, a timed-out zaak stays open in OpenZaak while the register shows the registration as lapsed — the
|
||||
two diverge. S-10c closes that gap: on expiry the domain must also cancel the zaak through the ACL
|
||||
(§8.1, the only code that talks to ZGW).
|
||||
|
||||
The non-obvious part is *how to represent "cancelled" in ZGW* alongside the existing "approved" close.
|
||||
The approval path (S-09b) sets the zaak's **eindstatus** (the terminal statustype) plus a resultaat. In
|
||||
ZGW a zaaktype has exactly one eindstatus — the highest-`volgnummer` statustype — and setting it is what
|
||||
closes the zaak (`einddatum`). A second *terminal* status would collide with that single-eindstatus rule.
|
||||
|
||||
## Decision
|
||||
|
||||
**Model cancellation as a distinct, non-terminal `Geannuleerd` statustype plus a distinct `Vervallen`
|
||||
resultaat, and resolve both the approval and cancellation statustype/resultaat by their omschrijving
|
||||
(name) rather than by position or the eindstatus flag alone.**
|
||||
|
||||
- **Seed.** `Geannuleerd` is seeded at `volgnummer` 2 — between `Ontvangen` (1) and the `Afgehandeld`
|
||||
eindstatus (3) — so it is a *non-terminal* status and never displaces the eindstatus the approval path
|
||||
resolves. A second resultaattype `Vervallen` (archiefnominatie `vernietigen`) is seeded beside the
|
||||
approval `Geregistreerd` (`blijvend_bewaren`); both draw their `selectielijstklasse` from the
|
||||
zaaktype's single `selectielijstProcestype` so they validate on publish.
|
||||
- **The ACL owns the mapping.** `OpenZaakGateway.SetZaakToCancellationStatusAsync` resolves `Geannuleerd`
|
||||
+ `Vervallen` by omschrijving and POSTs the resultaat then the status (OpenZaak requires a resultaat
|
||||
before a closing/terminal status), mirroring `SetZaakToEindstatusAsync`. Exposed as
|
||||
`AclService.CancelZaakAsync` behind the ACL endpoint `POST /annuleringen`. The omschrijvingen live as
|
||||
constants in the gateway — the ACL, not the domain, knows which ZGW status means what (§8.1).
|
||||
- **Approval now resolves its resultaat by name too.** With two resultaattypen present, taking the first
|
||||
is ambiguous (the Zaken API does not guarantee order), so the approval path resolves `Geregistreerd`
|
||||
by omschrijving. Its statustype resolution is unchanged (still the eindstatus).
|
||||
- **Domain wiring.** The `ExpireRegistrationWorker` calls `IAclClient.CancelZaakAsync(zaakUrl)` **before**
|
||||
advancing the aggregate to `Verlopen` (ACL-first, mirroring approval): if the ACL call fails the job is
|
||||
redelivered (§8.6) rather than leaving the aggregate `Verlopen` with an open zaak. The existing
|
||||
open-state guard stops a redelivered job from cancelling twice (a second resultaat would be a 400); a
|
||||
registration that lapsed before its zaak was opened has nothing to cancel.
|
||||
|
||||
## Consequences
|
||||
|
||||
**Positive**
|
||||
|
||||
- The domain aggregate and the ZGW zaak no longer diverge on timeout — both reflect the cancellation.
|
||||
- Reuses the approval close machinery (resultaat-then-status, ACL endpoint shape, ACL-first ordering), so
|
||||
the change is additive and §8 stays clean (only the ACL talks to ZGW).
|
||||
- Verified at two levels: an ACL↔OpenZaak integration test asserts the live zaak reaches `Geannuleerd`
|
||||
with a resultaat, and the domain verify script fires the real P30D timer and confirms the zaak is
|
||||
cancelled end-to-end.
|
||||
|
||||
**Negative / costs**
|
||||
|
||||
- `Geannuleerd` is non-terminal, so the cancelled zaak's `einddatum` is not set — it carries a
|
||||
cancellation status + resultaat but is not formally "closed" in ZGW. Accepted: the register reads the
|
||||
domain aggregate's status, and a single eindstatus per zaaktype is a ZGW constraint we chose not to
|
||||
fight. Formally closing a cancelled zaak (a second eindstatus, or reusing `Afgehandeld` with a
|
||||
`Vervallen` resultaat) is a possible follow-up.
|
||||
- The ACL couples to the seeded omschrijvingen (`Geregistreerd`/`Geannuleerd`/`Vervallen`) by string
|
||||
constants. This mirrors the existing implicit coupling to the catalogus (zaaktype URL, eindstatus) and
|
||||
is documented in the gateway.
|
||||
- Renumbering `Afgehandeld` from `volgnummer` 2 to 3 means a *stale* local catalogus must have its
|
||||
OpenZaak volumes reset for the change to take effect; CI reseeds a fresh catalogus each run.
|
||||
|
||||
## Alternatives considered
|
||||
|
||||
- **Shared eindstatus, distinct resultaat only** (reuse `Afgehandeld`, distinguish approval vs
|
||||
cancellation purely by the resultaat). ZGW-idiomatic and would set `einddatum` on cancellation too, but
|
||||
the register would show no visibly distinct cancellation *status*. Rejected in favour of the issue's
|
||||
explicit "distinct statustype + resultaattype" outcome, which makes the cancellation legible in ZGW.
|
||||
- **A second terminal (eindstatus) `Geannuleerd`.** Rejected: ZGW allows only one eindstatus per
|
||||
zaaktype (highest volgnummer); a second terminal status would either not close the zaak or collide with
|
||||
the approval eindstatus resolution.
|
||||
- **Passing the target omschrijvingen from the domain.** Rejected: which ZGW status means "cancelled" is
|
||||
ZGW vocabulary the ACL owns (§8.1); the domain says only "cancel this zaak".
|
||||
@@ -1,92 +0,0 @@
|
||||
# ADR-0020: The local stack self-seeds the zaaktype, DMN, and NRC abonnement at bring-up
|
||||
|
||||
- **Status:** Accepted
|
||||
- **Date:** 2026-07-22
|
||||
- **Deciders:** Respellion engineering
|
||||
- **Relates to:** S-B04 (#110). Local-stack twin of the seeding the verify-* scripts do for CI
|
||||
(`infra/run-domain-check.sh`, `infra/verify-notification-driver.py`). Superseded in part by S-27
|
||||
(#113), which would let the ACL resolve its zaaktype by identificatie and remove the URL injection.
|
||||
|
||||
## Context
|
||||
|
||||
`infra/docker-compose.local.yml` is the host-browser-friendly stack (`make local`) — the one a
|
||||
developer clicks through the portals with. It had drifted behind three slices, so a fresh bring-up
|
||||
could not complete the flow:
|
||||
|
||||
1. The ACL pointed at a placeholder zaaktype (`…/00000000-…`), so zaak creation failed with OpenZaak
|
||||
`400` and the registratie process stuck at `OpenZaakAanmaken` (S-05).
|
||||
2. `flowable-init` deployed only `registratie.bpmn`, not `diploma-eligibility.dmn`, so completing
|
||||
`WachtOpDocumenten` 404'd on the missing decision and never reached `Beoordelen` (S-10a/S-13).
|
||||
3. No NRC abonnement was registered, so notifications reached NRC and went nowhere — the projection
|
||||
and the openbaar register stayed empty (S-06).
|
||||
|
||||
The CI stack (`infra/docker-compose.yml`) does not hit this because its `verify-*` scripts seed the
|
||||
zaaktype, deploy the DMN, and register the abonnement at *test* time. The local stack has no such
|
||||
harness — a developer just runs `make local` and browses. The non-obvious wrinkle is (1): the
|
||||
zaaktype **UUID is assigned by OpenZaak at creation**, so the ACL's zaaktype URL is not knowable when
|
||||
the compose file is written and cannot be a static value.
|
||||
|
||||
## Decision
|
||||
|
||||
**Make the local stack self-seed at bring-up via one-shot init containers, and hand the ACL its
|
||||
server-assigned zaaktype URL through a shared-volume env file it sources on startup.**
|
||||
|
||||
- **DMN (gap 2).** `flowable-init` now deploys `diploma-eligibility.dmn` to the DMN engine
|
||||
(`/flowable-rest/dmn-api/dmn-repository/deployments`) as a separate deployment alongside the BPMN —
|
||||
identical to the CI `flowable-init`. Idempotent.
|
||||
- **Zaaktype + ACL wiring (gap 1).** A `local-seed` one-shot runs the existing
|
||||
`infra/openzaak/seed_catalogus.py` (`OZ_PUBLISH=1`) against OpenZaak and writes the resulting
|
||||
`Acl__Defaults__ZaaktypeUrl` / `…InformatieobjecttypeUrl` / `Acl__OpenZaak__BaseUrl` into
|
||||
`seed-env:/out/acl.env`. The ACL mounts that volume read-only and overrides its entrypoint to
|
||||
`sh -c 'set -a; . /seed/acl.env; set +a; exec dotnet Acl.Api.dll'`, so the real values override the
|
||||
compose placeholders before the app reads config. The ACL `depends_on: local-seed
|
||||
(service_completed_successfully)`.
|
||||
- **Abonnement (gap 3).** A `nrc-subscribe` one-shot registers an abonnement on the `zaken` kanaal
|
||||
pointing at the event-subscriber's `/notifications` callback (`infra/local/register-abonnement.py`).
|
||||
It is a leaf — nothing depends on it — so it can wait for the event-subscriber without forming a
|
||||
cycle with the ACL bootstrap.
|
||||
- **Reach OpenZaak/NRC by container IP, not service name.** Both the seed's ZTC calls and the
|
||||
abonnement's `callbackUrl` are validated by Django's URLValidator, which rejects a single-label host
|
||||
like `openzaak` / `event-subscriber`. The scripts resolve the target's container IP at runtime (as
|
||||
`infra/run-domain-check.sh` does), keeping the seeded URLs valid **and** host-consistent — the ACL's
|
||||
base URL is set to the same OpenZaak IP that owns the zaaktype URL.
|
||||
- **Acceptance.** `make verify-local` (`infra/run-local-flow-check.sh`) submits against a fresh stack
|
||||
and asserts the zaak opens, the case reaches the werkbak after documents, and the reference appears
|
||||
in the openbaar register — the red-to-green test for all three gaps.
|
||||
|
||||
## Consequences
|
||||
|
||||
**Positive**
|
||||
|
||||
- A fresh `make local` completes the full demo (submit → werkbak → openbaar) with no manual seeding —
|
||||
the slice's stated outcome.
|
||||
- Reuses the proven CI mechanisms (`seed_catalogus.py`, the DMN deploy, the abonnement driver) rather
|
||||
than inventing new ones; the only genuinely new piece is the entrypoint-sourced env file.
|
||||
- No service code changes — the fix is entirely in `infra/` (compose + two small scripts), so the ACL
|
||||
image and the CI stack are untouched.
|
||||
|
||||
**Negative / costs**
|
||||
|
||||
- The two compose files diverge further: the CI stack seeds at test time, the local stack at bring-up.
|
||||
Mitigated by reusing the same underlying scripts and cross-referencing them.
|
||||
- The ACL entrypoint override couples the local ACL to the seed-written file path (`/seed/acl.env`);
|
||||
if the seed fails, the ACL fails to start (loud, healthcheck-visible — preferred over silently
|
||||
running with a placeholder).
|
||||
- Container-IP-based URLs are re-derived on each bring-up; a keep-volumes restart with a changed
|
||||
OpenZaak IP relies on OpenZaak rebuilding hyperlinked URLs from the request host (it does) so the
|
||||
idempotent re-seed reports current-IP URLs.
|
||||
|
||||
## Alternatives considered
|
||||
|
||||
- **ACL resolves its zaaktype by identificatie (`BIG-REGISTRATIE`) at startup.** The cleaner,
|
||||
less-brittle design — no server-assigned URL to capture — and it would help the CI stack too. But it
|
||||
changes a service's runtime behaviour and its config contract, needs new ACL tests + mutation
|
||||
coverage, and still needs a seed step to *create* the zaaktype. Deliberately split out as its own
|
||||
slice with its own ADR (S-27 / #113) rather than folded into this infra-only fix.
|
||||
- **A documented `make local-seed` step run after `make local`.** Smallest change, but it fails the
|
||||
slice's "no manual seeding" outcome — the local stack is exactly the one meant to just work in a
|
||||
browser. Rejected.
|
||||
- **Fixed zaaktype UUID via OpenZaak `setup_configuration`/fixtures.** OpenZaak assigns UUIDs on POST;
|
||||
declaratively creating a fully *published* zaaktype (statustypen + resultaattypen validated against
|
||||
the Selectielijst + roltypen + iot relations) is not something `setup_configuration` supports
|
||||
cleanly in 1.28.2. Rejected as more fragile than reusing `seed_catalogus.py`.
|
||||
@@ -1,67 +0,0 @@
|
||||
# ADR-0021: The ACL resolves its zaaktype by identificatie, not a pinned URL
|
||||
|
||||
- **Status:** Accepted
|
||||
- **Date:** 2026-07-22
|
||||
- **Deciders:** Respellion engineering
|
||||
- **Relates to:** S-27 (#113), proposed in #117. The cleaner design deliberately split out of S-B04
|
||||
(#110, ADR-0020), which fixed the local stack with an infra-only bootstrap.
|
||||
|
||||
## Context
|
||||
|
||||
The ACL was handed a **pinned zaaktype URL** (`Acl__Defaults__ZaaktypeUrl`) and diploma
|
||||
informatieobjecttype URL. OpenZaak assigns those UUIDs at creation, so the URL is not knowable when
|
||||
the compose file is written — every stack had to seed the catalogus and then capture + inject the
|
||||
resulting URLs out of band: `run-domain-check.sh` for CI, and the `local-seed` → `acl.env` bootstrap
|
||||
(ADR-0020) for `make local`. Brittle, and a stale/placeholder URL failed opaquely (OpenZaak 400).
|
||||
|
||||
## Decision
|
||||
|
||||
**The ACL resolves its zaaktype (by `identificatie`) and diploma informatieobjecttype (by
|
||||
`omschrijving`) from OpenZaak's Catalogi API, instead of being handed the URLs.**
|
||||
|
||||
- **Config:** `AclDefaults.ZaaktypeUrl`/`InformatieobjecttypeUrl` → `ZaaktypeIdentificatie`
|
||||
(`BIG-REGISTRATIE`) / `InformatieobjecttypeOmschrijving` (`Diploma`).
|
||||
- **Lookup (gateway, §8.1):** `GET /catalogi/api/v1/zaaktypen?status=definitief&identificatie=…` →
|
||||
the published zaaktype URL; `GET /catalogi/api/v1/informatieobjecttypen?status=definitief` matched
|
||||
on `omschrijving`. Reuses the gateway's existing catalogus-query machinery.
|
||||
- **Timing = lazy + cached (`CachedZaaktypeCatalog`).** Resolve on first use (first zaak open /
|
||||
document store) and cache for the process lifetime. Lazy avoids a startup ordering coupling — the
|
||||
ACL never crash-loops when it boots before the catalogus is published. A **failed** resolution is
|
||||
not cached, so it is retried on the next call (e.g. once the zaaktype is published); a restart
|
||||
re-resolves.
|
||||
- **Failure mode:** no published match → a clear "No published zaaktype with identificatie '…' found
|
||||
in OpenZaak — is the BIG catalogus seeded and published?" error, replacing the opaque placeholder
|
||||
400.
|
||||
|
||||
## Consequences
|
||||
|
||||
**Positive**
|
||||
|
||||
- No stack captures or injects a server-assigned URL any more: `run-domain-check.sh` drops the
|
||||
`ACL_ZAAKTYPE_URL`/`ACL_INFORMATIEOBJECTTYPE_URL` capture+inject, `docker-compose.yml`/`.local.yml`
|
||||
drop the placeholder URL env, and `local-seed`/`acl.env` shrink to a single line. The ACL
|
||||
self-configures from the catalogus it already talks to.
|
||||
- The failure mode is legible (a named error instead of a 400 on a zeros-UUID).
|
||||
|
||||
**Negative / costs**
|
||||
|
||||
- The ACL still needs its OpenZaak **BaseUrl** pointed at a **URL-valid host (a container IP)**, so
|
||||
the base-URL injection from ADR-0020 stays (the local `acl.env` now carries only that; CI keeps
|
||||
`ACL_OPENZAAK_BASEURL`). This is **not** something S-27 can remove: OpenZaak validates the
|
||||
`zaaktype` field on zaak-create with Django's URLValidator and **rejects a single-label host**
|
||||
(`http://openzaak:8000/…` → `zaaktype: bad-url, "Voer een geldige URL in."`, confirmed empirically).
|
||||
So ADR-0020's `seed-env` volume + ACL entrypoint shim are **simplified, not deleted**.
|
||||
- New branching in the gateway/resolver → unit + integration test surface; the mutation ratchet
|
||||
covers it (§5).
|
||||
- A seed step still **creates + publishes** the zaaktype (this ADR changes only discovery). Reaching
|
||||
OpenZaak's Catalogi API to *seed* likewise needs the IP host (its query params hit the same
|
||||
URLValidator) — unchanged from before.
|
||||
|
||||
## Alternatives considered
|
||||
|
||||
- **Resolve at startup** (eager). Simpler cache, but reintroduces the ordering coupling (crash-loop
|
||||
if the catalogus isn't published yet). Rejected in favour of lazy.
|
||||
- **Per-request resolution** (no cache). No stale-cache risk, but a Catalogi lookup on every ACL
|
||||
operation. Rejected; a process-lifetime cache with restart-to-refresh is enough here.
|
||||
- **Keep the pinned URL** (status quo / ADR-0020 only). Rejected — the brittleness this ADR removes is
|
||||
exactly what S-27 was carved out to fix.
|
||||
@@ -5,55 +5,6 @@ copy-pasteable walkthrough against a local `make up` stack.
|
||||
|
||||
---
|
||||
|
||||
## S-B04 — `make local` completes the whole flow with no manual seeding (#110, ADR-0020)
|
||||
|
||||
**Outcome:** the host-browser stack (`make local`) now self-seeds at bring-up — it publishes the BIG
|
||||
zaaktype and wires the ACL to it, deploys the `diploma-eligibility` DMN, and registers the NRC
|
||||
abonnement — so a fresh bring-up runs submit → werkbak → openbaar without the manual seeding the
|
||||
`verify-*` scripts do for CI. (Previously the process stuck at `OpenZaakAanmaken`, the werkbak stayed
|
||||
empty, and the openbaar register showed nothing.)
|
||||
|
||||
```bash
|
||||
# 1. Fresh bring-up (self-seeding init containers: local-seed, nrc-subscribe; DMN in flowable-init).
|
||||
make local
|
||||
|
||||
# 2. Assert the whole flow works with no manual seeding — submit opens a zaak, documents route it to
|
||||
# the werkbak, and the reference appears in the openbaar register:
|
||||
make verify-local # → "OK — a fresh local stack completed the flow with no manual seeding ..."
|
||||
|
||||
# 3. Or by hand in the browser: log in at http://localhost:8140 (jan-burger / test123), submit +
|
||||
# upload a PDF, then approve it in the werkbak at http://localhost:8142 (merel-behandelaar /
|
||||
# test123); it shows as INGESCHREVEN in the openbaar register at http://localhost:8141.
|
||||
```
|
||||
|
||||
> The zaaktype is discovered by the ACL itself since S-27 (below); `local-seed`'s `acl.env` now
|
||||
> carries only OpenZaak's IP base URL, which the ACL still needs because OpenZaak rejects a
|
||||
> single-label host on zaak-create (ADR-0020 + ADR-0021).
|
||||
|
||||
---
|
||||
|
||||
## S-27 — ACL resolves its zaaktype by identificatie, not a pinned URL (#113, ADR-0021)
|
||||
|
||||
**Outcome:** the ACL discovers its BIG zaaktype (by `identificatie`) and diploma informatieobjecttype
|
||||
(by `omschrijving`) from OpenZaak's Catalogi API, instead of being handed the server-assigned URLs.
|
||||
No user-visible behaviour change — the flow runs exactly as before — but no stack captures/injects a
|
||||
zaaktype URL any more, and a missing catalogus now fails with a clear message instead of an opaque 400.
|
||||
|
||||
```bash
|
||||
# The live ACL↔OpenZaak integration test proves resolution against a real seeded OpenZaak:
|
||||
make verify-acl # → "resolves the published BIG-REGISTRATIE zaaktype + Diploma informatieobjecttype by business key"
|
||||
|
||||
# End-to-end unchanged (the ACL self-discovers the zaaktype during the flow):
|
||||
make verify-local # local stack — still green, now with no zaaktype-URL injection
|
||||
make verify-domain # CI stack — recreates the ACL pointed only at OpenZaak's IP (no URL to inject)
|
||||
```
|
||||
|
||||
> The ACL still needs its OpenZaak base URL at a URL-valid host (a container IP): OpenZaak's
|
||||
> URLValidator rejects a single-label host like `openzaak:8000` on zaak-create. So ADR-0020's base-URL
|
||||
> injection stays; only the zaaktype/informatieobjecttype **URL** injection is gone (ADR-0021).
|
||||
|
||||
---
|
||||
|
||||
## S-08d — Walking skeleton complete: browser → submit, end-to-end
|
||||
|
||||
**Outcome:** the self-service portal is served in the stack and the full front-of-house happy path
|
||||
@@ -347,187 +298,3 @@ interrupting boundary event ends it → the werkbak drops the case.
|
||||
> DigiD submit → trek aanvraag in → ingetrokken is the Playwright happy path
|
||||
> (`tests/e2e/withdrawal.spec.ts`); the owner-scoping + workflow cancellation are covered by the
|
||||
> `Een registratie intrekken` acceptance scenarios and the domain live check.
|
||||
|
||||
## S-14 — Beoordeling escalation: 14 days unclaimed → teamlead (#15, ADR-0015)
|
||||
|
||||
A beoordeling a behandelaar does not pick up within 14 days escalates to the teamlead. A
|
||||
non-interrupting boundary timer on the `Beoordelen` task fires a `BeoordelingEscaleren` external task;
|
||||
the domain's escalation worker reassigns the still-open task's candidate group from `behandelaar` to
|
||||
`teamlead`, so it moves from the behandelaar werkbak into the teamlead's. The `Beoordelen` task keeps
|
||||
its identity throughout — only who may claim it changes.
|
||||
|
||||
The timer is 14 days, so the demo fires it early through Flowable's management API (exactly what the
|
||||
verify-domain check automates):
|
||||
|
||||
```bash
|
||||
# 1. Submit at the self-service portal (http://localhost:8140/, jan-burger / test123). The case
|
||||
# parks at Beoordelen, visible in the behandelaar werkbak (http://localhost:8142/, merel-behandelaar)
|
||||
# but NOT claimed.
|
||||
#
|
||||
# 2. Find the parked instance and its Beoordelen task, then fire the boundary timer early:
|
||||
FL=http://localhost:8090/flowable-rest/service
|
||||
PID=$(curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
|
||||
-d '{"processDefinitionKey":"registratie","taskDefinitionKey":"Beoordelen"}' \
|
||||
| python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["processInstanceId"])')
|
||||
TID=$(curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
|
||||
-d '{"processDefinitionKey":"registratie","taskDefinitionKey":"Beoordelen"}' \
|
||||
| python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["id"])')
|
||||
TJ=$(curl -s -u rest-admin:test "$FL/management/timer-jobs?processInstanceId=$PID" \
|
||||
| python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["id"])')
|
||||
curl -s -u rest-admin:test -X POST "$FL/management/timer-jobs/$TJ" \
|
||||
-H 'Content-Type: application/json' -d '{"action":"move"}'
|
||||
AJ=$(curl -s -u rest-admin:test "$FL/management/jobs?processInstanceId=$PID" \
|
||||
| python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["id"])')
|
||||
curl -s -u rest-admin:test -X POST "$FL/management/jobs/$AJ" \
|
||||
-H 'Content-Type: application/json' -d '{"action":"execute"}'
|
||||
#
|
||||
# 3. Within a couple of poll cycles the task's candidate group flips to teamlead:
|
||||
curl -s -u rest-admin:test "$FL/runtime/tasks/$TID/identitylinks" # → [{"group":"teamlead","type":"candidate"}]
|
||||
```
|
||||
|
||||
**The path:** BPMN non-interrupting `P14D` boundary timer on `Beoordelen` → `BeoordelingEscaleren`
|
||||
external task → domain escalation worker (`BeoordelingEscalatiePump`) → Workflow Client swaps the task's
|
||||
candidate group behandelaar → teamlead (§8.2).
|
||||
|
||||
> Both branches (escalate after 14 days; no-op when completed in time) are covered by the
|
||||
> `Een beoordeling escaleren` acceptance scenarios and the Workflow Client unit tests; the timer firing
|
||||
> and reassignment are asserted live by the verify-domain check.
|
||||
|
||||
## S-13 — Diploma-eligibility: foreign diplomas route through CBGV-advies (#14, ADR-0016)
|
||||
|
||||
A registration's diploma origin decides its route. A DMN service task in the registratie
|
||||
process evaluates the `diploma-eligibility` decision on the `diplomaOrigin` start variable: a
|
||||
**foreign** (Buitenlands) diploma is routed through an extra **CBGV-advies** user task before
|
||||
beoordeling; a **domestic** (Binnenlands) one goes straight to beoordeling. The decision lives in the
|
||||
DMN, not in code — a beheerder can read and adjust the decision table directly.
|
||||
|
||||
The self-service portal's eIDAS→foreign wiring is a later slice; for now the origin is submitted to
|
||||
the domain directly, so the demo drives it through the domain endpoint:
|
||||
|
||||
```bash
|
||||
# 1. Submit a foreign-diploma registration to the domain (note the returned Location/reference):
|
||||
DOM=http://localhost:8080 # domain service
|
||||
curl -s -i -X POST "$DOM/registrations" -H 'Content-Type: application/json' \
|
||||
-d '{"bsn":"123456782","diplomaOrigin":"Buitenlands"}' | grep -i '^location:'
|
||||
#
|
||||
# 2. Once the zaak is opened, the process first parks at WachtOpDocumenten (S-10a); complete that task
|
||||
# (documents received) — then it parks at the CBGV-advies task (NOT Beoordelen). In Flowable:
|
||||
FL=http://localhost:8090/flowable-rest/service
|
||||
curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
|
||||
-d '{"processDefinitionKey":"registratie","taskDefinitionKey":"CBGVAdvies"}' | python3 -m json.tool
|
||||
#
|
||||
# 3. Complete the CBGV-advies task; the case then advances to the regular Beoordelen task:
|
||||
TID=$(curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
|
||||
-d '{"processDefinitionKey":"registratie","taskDefinitionKey":"CBGVAdvies"}' \
|
||||
| python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["id"])')
|
||||
curl -s -u rest-admin:test -X POST "$FL/runtime/tasks/$TID" \
|
||||
-H 'Content-Type: application/json' -d '{"action":"complete"}'
|
||||
# A domestic submission (default, or "Binnenlands") skips CBGV-advies and parks straight at Beoordelen.
|
||||
```
|
||||
|
||||
**The path:** domain sets the `diplomaOrigin` start variable → registratie process DMN
|
||||
DMN service task sets `route` → exclusive gateway → foreign: `CBGVAdvies` user task → `Beoordelen`;
|
||||
domestic: `Beoordelen` directly (§8.2, ADR-0016).
|
||||
|
||||
> The domestic/foreign paths are covered by the `Een diploma op herkomst routeren` acceptance
|
||||
> scenarios and unit tests (the origin is carried into the process); the DMN decision and the
|
||||
> foreign→CBGV routing are asserted live by the verify-domain check.
|
||||
|
||||
## S-10a — Document wait + 30-day timeout cancels the registration (#102, ADR-0017)
|
||||
|
||||
After the zaak is opened the registratie process parks at a **WachtOpDocumenten** user task, waiting
|
||||
for the citizen's documents (their diploma). Two things can happen:
|
||||
|
||||
- **Documents arrive in time** → the task completes and the process continues to the diploma-eligibility
|
||||
routing (S-13) → beoordeling.
|
||||
- **30 days pass with no documents** → an interrupting `P30D` boundary timer cancels the wait, runs the
|
||||
`RegistratieVerlopen` external task, and the domain expires the registration to the terminal status
|
||||
**VERLOPEN** (the case is cancelled).
|
||||
|
||||
The "documents received" trigger is wired end-to-end in S-10a: the self-service page shows a
|
||||
**"Documenten aanleveren"** button after submit (portal → BFF → domain → completes the wait). S-10b
|
||||
turns that into a real file upload stored in the ZGW Documenten API via the ACL. The timeout branch is
|
||||
demonstrated by firing the 30-day timer early via the management API.
|
||||
|
||||
```bash
|
||||
DOM=http://localhost:8080 # domain service
|
||||
FL=http://localhost:8090/flowable-rest/service # flowable-rest
|
||||
|
||||
# 1. Submit a registration; once the zaak is opened it parks at WachtOpDocumenten:
|
||||
curl -s -i -X POST "$DOM/registrations" -H 'Content-Type: application/json' \
|
||||
-d '{"bsn":"123456782"}' | grep -i '^location:' # note the /registrations/<id> reference
|
||||
WQ='{"processDefinitionKey":"registratie","taskDefinitionKey":"WachtOpDocumenten"}'
|
||||
|
||||
# 2a. Documents-in-time: complete the WachtOpDocumenten task → the process advances to beoordeling.
|
||||
TID=$(curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
|
||||
-d "$WQ" | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["id"])')
|
||||
curl -s -u rest-admin:test -X POST "$FL/runtime/tasks/$TID" \
|
||||
-H 'Content-Type: application/json' -d '{"action":"complete"}'
|
||||
|
||||
# 2b. Timeout: instead of completing it, fire the 30-day timer early via the management API. Find the
|
||||
# instance's timer job, "move" it to executable; the async executor fires the interrupting event.
|
||||
PID=$(curl -s -u rest-admin:test -X POST "$FL/query/tasks" -H 'Content-Type: application/json' \
|
||||
-d "$WQ" | python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["processInstanceId"])')
|
||||
JID=$(curl -s -u rest-admin:test "$FL/management/timer-jobs?processInstanceId=$PID" \
|
||||
| python3 -c 'import sys,json;print(json.load(sys.stdin)["data"][0]["id"])')
|
||||
curl -s -u rest-admin:test -X POST "$FL/management/timer-jobs/$JID" \
|
||||
-H 'Content-Type: application/json' -d '{"action":"move"}'
|
||||
# The RegistratieVerlopen worker then expires the aggregate — read it back as VERLOPEN:
|
||||
curl -s "$DOM/registrations/<id>" # → {"status":"Verlopen", ...}
|
||||
```
|
||||
|
||||
**The path:** registratie process parks at `WachtOpDocumenten` → documents received completes it (→
|
||||
routing → `Beoordelen`), OR the `P30D` interrupting timer fires → `RegistratieVerlopen` external task
|
||||
→ domain worker expires the aggregate to `Verlopen` → `endVerlopen` (§8.2, ADR-0017).
|
||||
|
||||
> Both branches are covered by the `Een documenttermijn laten verlopen` acceptance scenarios (worker +
|
||||
> aggregate) and unit tests; the wait completion and the 30-day timer firing are asserted live by the
|
||||
> verify-domain check.
|
||||
|
||||
## S-10b — Diploma upload stored in the ZGW Documenten API (#103, ADR-0018)
|
||||
|
||||
The self-service "Documenten aanleveren" action (S-10a) is now a **real file upload**: after submitting,
|
||||
the citizen picks a PDF and uploads it. The portal base64-encodes the file client-side and posts it to
|
||||
the BFF; the BFF forwards it to the domain, which stores it via the **ACL** as a ZGW
|
||||
`enkelvoudiginformatieobject` in the **Documenten (DRC) API** and relates it to the zaak — then completes
|
||||
the `WachtOpDocumenten` wait so beoordeling can proceed. Per §8.1 only the ACL talks to ZGW.
|
||||
|
||||
```bash
|
||||
make up
|
||||
# 1. Log in as jan-burger / test123, submit, then — once the openbaar register shows the row —
|
||||
# choose a PDF under "Documenten aanleveren" and upload it. The page confirms "aangeleverd".
|
||||
open http://localhost:8140
|
||||
#
|
||||
# 2. Automated: the walking-skeleton e2e now uploads a real PDF before the behandelaar approves.
|
||||
make verify-e2e
|
||||
#
|
||||
# 3. The ACL integration test proves the document is really created in the Documenten API and
|
||||
# related to the zaak (against a live OpenZaak):
|
||||
make verify-acl # → "Storing a diploma creates a real informatieobject related to the zaak"
|
||||
```
|
||||
|
||||
**The path:** portal (base64) → BFF `POST /self-service/registrations/{id}/documents` → domain
|
||||
`ProvideDocuments` → ACL `POST /documenten` → ZGW `enkelvoudiginformatieobjecten` +
|
||||
`zaakinformatieobjecten`; the wait is then completed and the case advances to Beoordelen (§8.1, ADR-0018).
|
||||
|
||||
## S-10c — the ZGW zaak is cancelled when the document term lapses (#106)
|
||||
|
||||
When the 30-day document term lapses (S-10a), the domain no longer only marks the aggregate `Verlopen` —
|
||||
it now also cancels the **ZGW zaak** through the ACL, so OpenZaak and the register agree. The zaak is set
|
||||
to a distinct, non-terminal **`Geannuleerd`** status with a **`Vervallen`** resultaat (as opposed to the
|
||||
approval `Afgehandeld` + `Geregistreerd`), resolved by name in the ACL (§8.1, ADR-0019).
|
||||
|
||||
```bash
|
||||
# 1. The ACL integration test proves cancellation records the Geannuleerd status + a resultaat
|
||||
# against a live OpenZaak:
|
||||
make verify-acl # → "Cancelling a zaak records the geannuleerd status and a resultaat"
|
||||
#
|
||||
# 2. End-to-end: the domain check submits a registration, fires its 30-day timer early, and asserts
|
||||
# the timeout worker both expires the registration (VERLOPEN) and cancels its zaak (Geannuleerd):
|
||||
make verify-domain # → "the timed-out registration's zaak was cancelled to Geannuleerd in OpenZaak"
|
||||
```
|
||||
|
||||
**The path:** Flowable P30D timer → `RegistratieVerlopen` job → domain `ExpireRegistrationWorker` → ACL
|
||||
`POST /annuleringen` → ZGW `resultaten` + `statussen` (Geannuleerd); the aggregate then moves to
|
||||
`Verlopen`. The ACL cancels the zaak **before** the aggregate is expired, so a failed ZGW call leaves the
|
||||
job for redelivery rather than diverging the two (ADR-0019).
|
||||
|
||||
@@ -14,7 +14,6 @@ All test users share the password **`test123`**.
|
||||
| Realm | Mimics | User | Identifying claim |
|
||||
|---|---|---|---|
|
||||
| `digid` | DigiD (burgers) | `jan-burger` | `bsn` = `123456782` |
|
||||
| `digid` | DigiD (burgers) | `sanne-burger` | `bsn` = `231477813` (S-26 resume e2e — its own user so it can leave an open registration) |
|
||||
| `eherkenning` | eHerkenning (bedrijven) | `acme-ondernemer` | `kvk` = `12345678` |
|
||||
| `eidas` | eIDAS (EU) | `pierre-dupont` | `eidas_id` = `FR/NL/AB-1234-5678` |
|
||||
| `medewerker` | Internal staff | `merel-behandelaar` | role `behandelaar` |
|
||||
|
||||
@@ -1,12 +1,7 @@
|
||||
# LOCAL development stack — runs with a plain `docker compose up`, no make / no
|
||||
# external seed step / no bash. Use this on a local engine (Docker Desktop on Windows or
|
||||
# seed step / no bash. Use this on a local engine (Docker Desktop on Windows or
|
||||
# macOS, or rootless Podman on Linux).
|
||||
#
|
||||
# Self-seeding (S-B04, #110, ADR-0020): unlike the CI stack — where the verify-* scripts seed the
|
||||
# zaaktype and register the NRC abonnement at test time — this stack does that itself, via one-shot
|
||||
# init containers (local-seed, nrc-subscribe) + a DMN deploy in flowable-init, so a fresh bring-up
|
||||
# completes the whole flow with no manual steps. `make verify-local` asserts it.
|
||||
#
|
||||
# docker compose -f infra/docker-compose.local.yml up -d --build # podman
|
||||
# docker compose -f infra/docker-compose.local.yml up -d --build --wait # Docker Desktop
|
||||
# docker compose -f infra/docker-compose.local.yml down --volumes
|
||||
@@ -262,79 +257,38 @@ services:
|
||||
restart: "no"
|
||||
volumes:
|
||||
- ../workflows/registratie.bpmn:/work/registratie.bpmn:ro,z
|
||||
- ../workflows/diploma-eligibility.dmn:/work/diploma-eligibility.dmn:ro,z
|
||||
command:
|
||||
- sh
|
||||
- -c
|
||||
- |
|
||||
svc=http://flowable-rest:8080/flowable-rest/service/repository/deployments
|
||||
dmn=http://flowable-rest:8080/flowable-rest/dmn-api/dmn-repository/deployments
|
||||
until curl -sf -u rest-admin:test "$$svc" >/dev/null 2>&1; do echo "waiting for flowable-rest..."; sleep 3; done
|
||||
# Deploy the DMN to the DMN engine and the BPMN to the process engine as SEPARATE deployments:
|
||||
# flowable-rest does NOT cascade a .dmn bundled in a process .bar into the DMN engine, so the DMN
|
||||
# must go via dmn-api. The registratie process's DMN service task then resolves the decision across
|
||||
# deployments by key (S-13, ADR-0016). Without this the WachtOpDocumenten completion 404s on the
|
||||
# missing decision and the case never reaches Beoordelen (S-B04). Both steps are idempotent.
|
||||
if curl -s -u rest-admin:test "$$dmn" | grep -q '"name":"diploma-eligibility.dmn"'; then
|
||||
echo "diploma-eligibility DMN already deployed; skip"
|
||||
base=http://flowable-rest:8080/flowable-rest/service/repository/deployments
|
||||
until curl -sf -u rest-admin:test "$$base" >/dev/null 2>&1; do echo "waiting for flowable-rest..."; sleep 3; done
|
||||
if curl -s -u rest-admin:test "$$base?name=registratie" | grep -q '"name":"registratie"'; then
|
||||
echo "registratie already deployed; skip"
|
||||
else
|
||||
curl -sf -u rest-admin:test -F 'file=@/work/diploma-eligibility.dmn;filename=diploma-eligibility.dmn' "$$dmn" >/dev/null && echo "deployed diploma-eligibility DMN"
|
||||
fi
|
||||
if curl -s -u rest-admin:test "$$svc?name=registratie" | grep -q '"name":"registratie"'; then
|
||||
echo "registratie BPMN already deployed; skip"
|
||||
else
|
||||
curl -sf -u rest-admin:test -F 'file=@/work/registratie.bpmn;filename=registratie.bpmn' "$$svc" >/dev/null && echo "deployed registratie BPMN"
|
||||
curl -sf -u rest-admin:test -F 'file=@/work/registratie.bpmn;filename=registratie.bpmn' "$$base" >/dev/null && echo "deployed registratie"
|
||||
fi
|
||||
depends_on:
|
||||
flowable-rest:
|
||||
condition: service_started
|
||||
networks: [cg]
|
||||
|
||||
# ── Local bootstrap: seed the zaaktype + wire the ACL (S-B04, #110, ADR-0020) ─────────────────
|
||||
# The zaaktype UUID is assigned by OpenZaak at creation, so it can't be a static value in this
|
||||
# file. This one-shot seeds + publishes the BIG zaaktype (and the Diploma informatieobjecttype)
|
||||
# and writes their server-assigned URLs into a shared volume as acl.env, which the ACL sources on
|
||||
# startup (below). It is the local-stack equivalent of what infra/run-domain-check.sh does for CI.
|
||||
# Reaches OpenZaak by its container IP because a single-label host fails OpenZaak's URLValidator.
|
||||
local-seed:
|
||||
image: docker.io/library/python:3-slim
|
||||
restart: "no"
|
||||
volumes:
|
||||
- ./openzaak/seed_catalogus.py:/work/seed_catalogus.py:ro,z
|
||||
- ./local/seed-zaaktype.sh:/work/seed-zaaktype.sh:ro,z
|
||||
- seed-env:/out
|
||||
command: ["sh", "/work/seed-zaaktype.sh"]
|
||||
depends_on:
|
||||
openzaak:
|
||||
condition: service_healthy
|
||||
networks: [cg]
|
||||
|
||||
# ── ACL ──────────────────────────────────────────────────────────────────
|
||||
acl:
|
||||
build:
|
||||
context: ../services/acl
|
||||
dockerfile: Dockerfile
|
||||
image: register-referentie/acl:dev
|
||||
# The ACL discovers its zaaktype + informatieobjecttype URLs from the Catalogi API by the business
|
||||
# keys below (S-27, ADR-0021), so no URL is injected. It still needs its OpenZaak BaseUrl pointed at
|
||||
# a URL-valid host (OpenZaak rejects a single-label host like `openzaak` on zaak-create), so the
|
||||
# local-seed one-shot writes that IP base into seed-env:/seed/acl.env, which the entrypoint sources
|
||||
# (set -a) before the app starts. A runtime-generated env file is why we override the entrypoint here
|
||||
# rather than use `env_file:` (which compose reads at parse time, before the seed has run).
|
||||
entrypoint: ["/bin/sh", "-c", "set -a; . /seed/acl.env; set +a; exec dotnet Acl.Api.dll"]
|
||||
environment:
|
||||
Acl__OpenZaak__BaseUrl: http://openzaak:8000/ # placeholder; seed-env/acl.env supplies the IP base
|
||||
Acl__OpenZaak__BaseUrl: http://openzaak:8000/
|
||||
Acl__OpenZaak__ClientId: big-reference-seed
|
||||
Acl__OpenZaak__Secret: insecure-dev-secret-change-me
|
||||
Acl__Defaults__Bronorganisatie: "517439943"
|
||||
Acl__Defaults__VerantwoordelijkeOrganisatie: "517439943"
|
||||
Acl__Defaults__Vertrouwelijkheidaanduiding: openbaar
|
||||
Acl__Defaults__ZaaktypeIdentificatie: BIG-REGISTRATIE
|
||||
Acl__Defaults__InformatieobjecttypeOmschrijving: Diploma
|
||||
Acl__Defaults__ZaaktypeUrl: ${ACL_ZAAKTYPE_URL:-http://openzaak:8000/catalogi/api/v1/zaaktypen/00000000-0000-0000-0000-000000000000}
|
||||
ports:
|
||||
- "8100:8080"
|
||||
volumes:
|
||||
- seed-env:/seed:ro
|
||||
healthcheck:
|
||||
test: ["CMD", "curl", "-fsS", "http://localhost:8080/health"]
|
||||
interval: 5s
|
||||
@@ -344,8 +298,6 @@ services:
|
||||
depends_on:
|
||||
openzaak:
|
||||
condition: service_healthy
|
||||
local-seed:
|
||||
condition: service_completed_successfully
|
||||
networks: [cg]
|
||||
|
||||
# ── BFF ──────────────────────────────────────────────────────────────────
|
||||
@@ -448,31 +400,6 @@ services:
|
||||
condition: service_healthy
|
||||
networks: [cg]
|
||||
|
||||
# ── Local bootstrap: register the NRC abonnement (S-B04, #110, ADR-0020) ──────────────────────
|
||||
# Without a subscription, OpenZaak's notifications reach NRC and are delivered nowhere, so the
|
||||
# projection (and the openbaar register) stay empty. This one-shot registers an abonnement on the
|
||||
# `zaken` kanaal pointing at the event-subscriber's /notifications callback — the CI equivalent is
|
||||
# infra/verify-notification-driver.py. The callback uses the event-subscriber's container IP (a
|
||||
# single-label host fails NRC's URLValidator). It is a leaf (nothing depends on it), so it can wait
|
||||
# for the event-subscriber without creating a cycle with the ACL bootstrap.
|
||||
nrc-subscribe:
|
||||
image: docker.io/library/python:3-slim
|
||||
restart: "no"
|
||||
volumes:
|
||||
- ./local/register-abonnement.py:/work/register-abonnement.py:ro,z
|
||||
environment:
|
||||
NRC_BASE: http://nrc-web:8000
|
||||
SINK_HOST: event-subscriber
|
||||
SINK_PORT: "8080"
|
||||
SINK_AUTH: ${NOTIFICATION_WEBHOOK_TOKEN:-Bearer big-reference-notifications}
|
||||
command: ["python", "/work/register-abonnement.py"]
|
||||
depends_on:
|
||||
nrc-web:
|
||||
condition: service_healthy
|
||||
event-subscriber:
|
||||
condition: service_started
|
||||
networks: [cg]
|
||||
|
||||
projection-api:
|
||||
build:
|
||||
context: ..
|
||||
@@ -565,8 +492,6 @@ volumes:
|
||||
nrc-db:
|
||||
flowable-db:
|
||||
projection-db:
|
||||
# Carries the seed-generated acl.env (server-assigned zaaktype URLs) from local-seed to the ACL.
|
||||
seed-env:
|
||||
|
||||
networks:
|
||||
cg:
|
||||
|
||||
+14
-29
@@ -15,12 +15,12 @@
|
||||
#
|
||||
# docker compose -f infra/docker-compose.yml up -d --build --wait
|
||||
#
|
||||
# After first boot, seed + publish the BIG catalogus:
|
||||
# OZ_PUBLISH=1 python infra/openzaak/seed_catalogus.py
|
||||
# The ACL discovers the zaaktype by identificatie (S-27, ADR-0021), so there is no URL to inject —
|
||||
# just point its BaseUrl at an OpenZaak host OpenZaak accepts on zaak-create (a container IP; a
|
||||
# single-label host is rejected):
|
||||
# ACL_OPENZAAK_BASEURL=http://<openzaak-ip>:8000/ docker compose -f infra/docker-compose.yml up -d acl
|
||||
# After first boot, seed the BIG catalogus and note the zaaktype URL:
|
||||
# python infra/openzaak/seed_catalogus.py
|
||||
# Then set ACL_ZAAKTYPE_URL in a .env file or your shell and re-up the acl
|
||||
# service:
|
||||
# export ACL_ZAAKTYPE_URL=http://openzaak:8000/catalogi/api/v1/zaaktypen/<uuid>
|
||||
# docker compose -f infra/docker-compose.yml up -d acl
|
||||
|
||||
services:
|
||||
|
||||
@@ -259,30 +259,19 @@ services:
|
||||
flowable-init:
|
||||
image: docker.io/curlimages/curl:latest
|
||||
restart: "no"
|
||||
# registratie.bpmn + diploma-eligibility.dmn are streamed into this external volume by
|
||||
# infra/seed-config.sh.
|
||||
# registratie.bpmn is streamed into this external volume by infra/seed-config.sh.
|
||||
volumes:
|
||||
- fl-bpmn:/work:ro
|
||||
command:
|
||||
- sh
|
||||
- -c
|
||||
- |
|
||||
svc=http://flowable-rest:8080/flowable-rest/service/repository/deployments
|
||||
dmn=http://flowable-rest:8080/flowable-rest/dmn-api/dmn-repository/deployments
|
||||
until curl -sf -u rest-admin:test "$$svc" >/dev/null 2>&1; do echo "waiting for flowable-rest..."; sleep 3; done
|
||||
# Deploy the DMN to the DMN engine and the BPMN to the process engine as SEPARATE deployments:
|
||||
# flowable-rest does NOT cascade a .dmn bundled in a process .bar into the DMN engine, so the DMN
|
||||
# must go via dmn-api. The process's DMN service task then resolves the decision across deployments
|
||||
# by key (S-13, ADR-0016). Both steps are idempotent (skip if already deployed).
|
||||
if curl -s -u rest-admin:test "$$dmn" | grep -q '"name":"diploma-eligibility.dmn"'; then
|
||||
echo "diploma-eligibility DMN already deployed; skip"
|
||||
base=http://flowable-rest:8080/flowable-rest/service/repository/deployments
|
||||
until curl -sf -u rest-admin:test "$$base" >/dev/null 2>&1; do echo "waiting for flowable-rest..."; sleep 3; done
|
||||
if curl -s -u rest-admin:test "$$base?name=registratie" | grep -q '"name":"registratie"'; then
|
||||
echo "registratie already deployed; skip"
|
||||
else
|
||||
curl -sf -u rest-admin:test -F 'file=@/work/diploma-eligibility.dmn;filename=diploma-eligibility.dmn' "$$dmn" >/dev/null && echo "deployed diploma-eligibility DMN"
|
||||
fi
|
||||
if curl -s -u rest-admin:test "$$svc?name=registratie" | grep -q '"name":"registratie"'; then
|
||||
echo "registratie BPMN already deployed; skip"
|
||||
else
|
||||
curl -sf -u rest-admin:test -F 'file=@/work/registratie.bpmn;filename=registratie.bpmn' "$$svc" >/dev/null && echo "deployed registratie BPMN"
|
||||
curl -sf -u rest-admin:test -F 'file=@/work/registratie.bpmn;filename=registratie.bpmn' "$$base" >/dev/null && echo "deployed registratie"
|
||||
fi
|
||||
depends_on:
|
||||
flowable-rest:
|
||||
@@ -304,12 +293,8 @@ services:
|
||||
Acl__Defaults__Bronorganisatie: "517439943"
|
||||
Acl__Defaults__VerantwoordelijkeOrganisatie: "517439943"
|
||||
Acl__Defaults__Vertrouwelijkheidaanduiding: openbaar
|
||||
# The ACL resolves the (server-assigned) zaaktype + diploma informatieobjecttype URLs from the
|
||||
# Catalogi API by these stable business keys (S-27, ADR-0021) — no URL to capture and inject.
|
||||
# BaseUrl above stays overridable because OpenZaak rejects a single-label host on zaak creation,
|
||||
# so verify-domain still points the ACL at OpenZaak's container IP.
|
||||
Acl__Defaults__ZaaktypeIdentificatie: BIG-REGISTRATIE
|
||||
Acl__Defaults__InformatieobjecttypeOmschrijving: Diploma
|
||||
# Override with the real zaaktype URL after running seed_catalogus.py.
|
||||
Acl__Defaults__ZaaktypeUrl: ${ACL_ZAAKTYPE_URL:-http://openzaak:8000/catalogi/api/v1/zaaktypen/00000000-0000-0000-0000-000000000000}
|
||||
ports:
|
||||
- "8100:8080"
|
||||
healthcheck:
|
||||
|
||||
@@ -35,35 +35,24 @@ services:
|
||||
condition: service_healthy
|
||||
networks: [cg]
|
||||
|
||||
# Deploys registratie.bpmn (process engine) and diploma-eligibility.dmn (DMN engine) via the REST
|
||||
# API once flowable-rest is up. Idempotent: skips each if already deployed.
|
||||
# Deploys workflows/registratie.bpmn via the REST API once flowable-rest is up.
|
||||
# Idempotent: skips if a deployment named "registratie" already exists.
|
||||
flowable-init:
|
||||
image: docker.io/curlimages/curl:latest
|
||||
restart: "no"
|
||||
# registratie.bpmn + diploma-eligibility.dmn are streamed into this external volume by
|
||||
# infra/seed-config.sh.
|
||||
# registratie.bpmn is streamed into this external volume by infra/seed-config.sh.
|
||||
volumes:
|
||||
- fl-bpmn:/work:ro
|
||||
command:
|
||||
- sh
|
||||
- -c
|
||||
- |
|
||||
svc=http://flowable-rest:8080/flowable-rest/service/repository/deployments
|
||||
dmn=http://flowable-rest:8080/flowable-rest/dmn-api/dmn-repository/deployments
|
||||
until curl -sf -u rest-admin:test "$$svc" >/dev/null 2>&1; do echo "waiting for flowable-rest..."; sleep 3; done
|
||||
# Deploy the DMN to the DMN engine and the BPMN to the process engine as SEPARATE deployments:
|
||||
# flowable-rest does NOT cascade a .dmn bundled in a process .bar into the DMN engine, so the DMN
|
||||
# must go via dmn-api. The process's DMN service task then resolves the decision across deployments
|
||||
# by key (S-13, ADR-0016). Both steps are idempotent (skip if already deployed).
|
||||
if curl -s -u rest-admin:test "$$dmn" | grep -q '"name":"diploma-eligibility.dmn"'; then
|
||||
echo "diploma-eligibility DMN already deployed; skip"
|
||||
base=http://flowable-rest:8080/flowable-rest/service/repository/deployments
|
||||
until curl -sf -u rest-admin:test "$$base" >/dev/null 2>&1; do echo "waiting for flowable-rest..."; sleep 3; done
|
||||
if curl -s -u rest-admin:test "$$base?name=registratie" | grep -q '"name":"registratie"'; then
|
||||
echo "registratie already deployed; skip"
|
||||
else
|
||||
curl -sf -u rest-admin:test -F 'file=@/work/diploma-eligibility.dmn;filename=diploma-eligibility.dmn' "$$dmn" >/dev/null && echo "deployed diploma-eligibility DMN"
|
||||
fi
|
||||
if curl -s -u rest-admin:test "$$svc?name=registratie" | grep -q '"name":"registratie"'; then
|
||||
echo "registratie BPMN already deployed; skip"
|
||||
else
|
||||
curl -sf -u rest-admin:test -F 'file=@/work/registratie.bpmn;filename=registratie.bpmn' "$$svc" >/dev/null && echo "deployed registratie BPMN"
|
||||
curl -sf -u rest-admin:test -F 'file=@/work/registratie.bpmn;filename=registratie.bpmn' "$$base" >/dev/null && echo "deployed registratie"
|
||||
fi
|
||||
depends_on:
|
||||
flowable-rest:
|
||||
|
||||
@@ -38,36 +38,6 @@
|
||||
"emailVerified": true,
|
||||
"credentials": [{ "type": "password", "value": "test123", "temporary": false }],
|
||||
"attributes": { "bsn": ["123456782"] }
|
||||
},
|
||||
{
|
||||
"username": "sanne-burger",
|
||||
"enabled": true,
|
||||
"firstName": "Sanne",
|
||||
"lastName": "Burger",
|
||||
"email": "sanne.burger@example.nl",
|
||||
"emailVerified": true,
|
||||
"credentials": [{ "type": "password", "value": "test123", "temporary": false }],
|
||||
"attributes": { "bsn": ["231477813"] }
|
||||
},
|
||||
{
|
||||
"username": "emma-burger",
|
||||
"enabled": true,
|
||||
"firstName": "Emma",
|
||||
"lastName": "Burger",
|
||||
"email": "emma.burger@example.nl",
|
||||
"emailVerified": true,
|
||||
"credentials": [{ "type": "password", "value": "test123", "temporary": false }],
|
||||
"attributes": { "bsn": ["231477805"] }
|
||||
},
|
||||
{
|
||||
"username": "lars-burger",
|
||||
"enabled": true,
|
||||
"firstName": "Lars",
|
||||
"lastName": "Burger",
|
||||
"email": "lars.burger@example.nl",
|
||||
"emailVerified": true,
|
||||
"credentials": [{ "type": "password", "value": "test123", "temporary": false }],
|
||||
"attributes": { "bsn": ["231477821"] }
|
||||
}
|
||||
]
|
||||
}
|
||||
|
||||
@@ -1,78 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Local-stack bootstrap (S-B04, #110, ADR-0020) — register the NRC abonnement.
|
||||
|
||||
Runs as the `nrc-subscribe` init container of infra/docker-compose.local.yml. Registers an
|
||||
abonnement on the `zaken` kanaal pointing at the event-subscriber's /notifications callback, so
|
||||
OpenZaak's notifications (zaak create + status set) reach the projection — without this the openbaar
|
||||
(public) register stays empty. This is what infra/verify-notification-driver.py does for CI (minus
|
||||
the test zaak it also creates).
|
||||
|
||||
The callback host is the event-subscriber's resolved **container IP**, not `event-subscriber`, because
|
||||
NRC validates callbackUrl with Django's URLValidator (a single-label host is rejected — same reason the
|
||||
zaaktype seed uses OpenZaak's IP). Idempotent + restart-safe: it removes any stale /notifications
|
||||
abonnement first, then registers one for the current IP. Stdlib only.
|
||||
|
||||
Env: NRC_BASE, SINK_HOST, SINK_PORT, SINK_AUTH, OZ_CLIENT_ID, OZ_SECRET.
|
||||
"""
|
||||
import base64, hashlib, hmac, json, os, socket, sys, time, urllib.error, urllib.request
|
||||
|
||||
NRC = os.environ.get("NRC_BASE", "http://nrc-web:8000").rstrip("/")
|
||||
SINK_HOST = os.environ.get("SINK_HOST", "event-subscriber")
|
||||
SINK_PORT = os.environ.get("SINK_PORT", "8080")
|
||||
SINK_AUTH = os.environ.get("SINK_AUTH", "Bearer big-reference-notifications")
|
||||
CID = os.environ.get("OZ_CLIENT_ID", "big-reference-seed")
|
||||
SECRET = os.environ.get("OZ_SECRET", "insecure-dev-secret-change-me")
|
||||
|
||||
|
||||
def token():
|
||||
b64 = lambda b: base64.urlsafe_b64encode(b).rstrip(b"=")
|
||||
seg = (
|
||||
b64(json.dumps({"alg": "HS256", "typ": "JWT"}, separators=(",", ":")).encode())
|
||||
+ b"."
|
||||
+ b64(json.dumps(
|
||||
{"iss": CID, "iat": int(time.time()), "client_id": CID,
|
||||
"user_id": "local-seed", "user_representation": "local-seed"},
|
||||
separators=(",", ":")).encode())
|
||||
)
|
||||
return (seg + b"." + b64(hmac.new(SECRET.encode(), seg, hashlib.sha256).digest())).decode()
|
||||
|
||||
|
||||
def call(method, url, body=None):
|
||||
data = json.dumps(body).encode() if body is not None else None
|
||||
req = urllib.request.Request(url, data=data, method=method, headers={
|
||||
"Authorization": "Bearer " + token(),
|
||||
"Content-Type": "application/json", "Accept": "application/json"})
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=30) as r:
|
||||
raw = r.read()
|
||||
return r.status, (json.loads(raw) if raw else None)
|
||||
except urllib.error.HTTPError as e:
|
||||
raw = e.read()
|
||||
return e.code, (json.loads(raw) if raw else None)
|
||||
|
||||
|
||||
def main():
|
||||
ip = socket.gethostbyname(SINK_HOST)
|
||||
callback = f"http://{ip}:{SINK_PORT}/notifications"
|
||||
|
||||
# Restart-safe: drop any prior /notifications abonnement (its IP may be stale) before creating a
|
||||
# fresh one for the current event-subscriber IP.
|
||||
status, body = call("GET", f"{NRC}/api/v1/abonnement")
|
||||
for ab in (body or []) if status == 200 else []:
|
||||
if str(ab.get("callbackUrl", "")).endswith("/notifications"):
|
||||
if ab.get("callbackUrl") == callback:
|
||||
print(f"abonnement already current: {ab['url']}")
|
||||
return
|
||||
call("DELETE", ab["url"])
|
||||
print(f"removed stale abonnement {ab['url']}")
|
||||
|
||||
status, ab = call("POST", f"{NRC}/api/v1/abonnement", {
|
||||
"callbackUrl": callback, "auth": SINK_AUTH,
|
||||
"kanalen": [{"naam": "zaken", "filters": {}}]})
|
||||
if status != 201:
|
||||
sys.exit(f"create abonnement -> {status}: {json.dumps(ab)}")
|
||||
print(f"abonnement registered: {ab['url']} -> {callback}")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,33 +0,0 @@
|
||||
#!/bin/sh
|
||||
# Local-stack bootstrap (S-B04, #110, ADR-0020) — the "seed zaaktype + wire the ACL" step.
|
||||
#
|
||||
# Runs as the `local-seed` init container of infra/docker-compose.local.yml. It seeds + publishes
|
||||
# the BIG zaaktype (and the Diploma informatieobjecttype) into OpenZaak, then writes the resulting
|
||||
# **server-assigned** URLs into /out/acl.env, which the ACL entrypoint sources before starting. This
|
||||
# is the local-stack equivalent of what infra/run-domain-check.sh does for CI: the zaaktype UUID is
|
||||
# assigned by OpenZaak at creation, so it can't be a static value in the compose file.
|
||||
#
|
||||
# Why the container IP and not the `openzaak` service name: OpenZaak validates URL query params
|
||||
# (e.g. ?catalogus=) with Django's URLValidator, which rejects a single-label host like `openzaak`.
|
||||
# Seeding against the resolved IP keeps the seeded URLs valid AND host-consistent with the ACL, which
|
||||
# we point at the same IP below. See docs/runbooks/gitea-actions-gotchas.md and ADR-0020.
|
||||
set -eu
|
||||
|
||||
oz_ip="$(python3 -c "import socket;print(socket.gethostbyname('openzaak'))")"
|
||||
OZ_BASE="http://${oz_ip}:8000"
|
||||
export OZ_BASE OZ_PUBLISH=1
|
||||
|
||||
echo ">> seeding + publishing the BIG zaaktype at ${OZ_BASE} (idempotent)"
|
||||
out="$(python3 /work/seed_catalogus.py)"
|
||||
echo "$out"
|
||||
|
||||
# Sanity-check that the zaaktype was actually published (the ACL discovers it by identificatie, S-27).
|
||||
printf '%s\n' "$out" | grep -q '^ZAAKTYPE_URL ' || { echo "ERROR: seed did not publish the zaaktype" >&2; exit 1; }
|
||||
|
||||
# The ACL resolves the zaaktype/informatieobjecttype URLs itself (S-27, ADR-0021); the only value it
|
||||
# still needs injected is the OpenZaak base URL at a URL-valid host (the container IP), because OpenZaak
|
||||
# rejects a single-label host on zaak-create. The ACL entrypoint sources this.
|
||||
cat > /out/acl.env <<EOF
|
||||
Acl__OpenZaak__BaseUrl=${OZ_BASE}/
|
||||
EOF
|
||||
echo ">> wrote /out/acl.env (base=${OZ_BASE}/)"
|
||||
Binary file not shown.
@@ -10,7 +10,7 @@ Creates (if absent):
|
||||
Auth uses the JWT client provisioned by setup_configuration (see ADR-0002).
|
||||
Stdlib only — no pip deps. Re-running is safe (matches existing by identifier).
|
||||
"""
|
||||
import base64, hashlib, hmac, json, os, sys, time, urllib.error, urllib.parse, urllib.request
|
||||
import base64, hashlib, hmac, json, os, sys, time, urllib.error, urllib.request
|
||||
|
||||
BASE = os.environ.get("OZ_BASE", "http://localhost:8000")
|
||||
CLIENT_ID = os.environ.get("OZ_CLIENT_ID", "big-reference-seed")
|
||||
@@ -77,12 +77,8 @@ def publish_zaaktype(zt):
|
||||
Selectielijst `selectielijstklasse` whose procestype matches the zaaktype's
|
||||
`selectielijstProcestype`, plus a `resultaattypeomschrijving`.
|
||||
"""
|
||||
# Ontvangen (begin) → Afgehandeld (eind, highest volgnummer). "Geannuleerd" (S-10c) sits between
|
||||
# them: a non-terminal status the document-timeout branch sets, so it never displaces the Afgehandeld
|
||||
# eindstatus the approval path resolves. Keyed by volgnummer on a fresh catalogus (CI reseeds); a
|
||||
# stale local stack must reset its OpenZaak volumes for the renumbering to take effect.
|
||||
have_st = {s.get("volgnummer") for s in find(f"/statustypen?zaaktype={zt['url']}&status=alles")}
|
||||
for volgnummer, omschrijving in [(1, "Ontvangen"), (2, "Geannuleerd"), (3, "Afgehandeld")]:
|
||||
for volgnummer, omschrijving in [(1, "Ontvangen"), (2, "Afgehandeld")]:
|
||||
if volgnummer not in have_st:
|
||||
st, body = api("POST", "/statustypen", {
|
||||
"omschrijving": omschrijving, "zaaktype": zt["url"], "volgnummer": volgnummer})
|
||||
@@ -99,42 +95,25 @@ def publish_zaaktype(zt):
|
||||
sys.exit(f"create roltype -> {st}: {json.dumps(body, indent=2)}")
|
||||
print("create roltype Aanvrager")
|
||||
|
||||
# Two resultaattypen, keyed by omschrijving so each is created independently (idempotent):
|
||||
# "Geregistreerd" — the approval outcome (S-09b)
|
||||
# "Vervallen" — the document-timeout cancellation outcome (S-10c)
|
||||
# Both selectielijstklassen must share the zaaktype's selectielijstProcestype, so pick two
|
||||
# Selectielijst resultaten from a single procestype and set that procestype on the zaaktype.
|
||||
have_rt = {r.get("omschrijving") for r in find(f"/resultaattypen?zaaktype={zt['url']}&status=alles")}
|
||||
wanted = [("Geregistreerd", "blijvend_bewaren"), ("Vervallen", "vernietigen")]
|
||||
if all(naam in have_rt for naam, _ in wanted):
|
||||
print("skip resultaattypen Geregistreerd + Vervallen")
|
||||
if find(f"/resultaattypen?zaaktype={zt['url']}&status=alles"):
|
||||
print("skip resultaattype Geregistreerd")
|
||||
else:
|
||||
# Anchor on the procestype of an arbitrary resultaat, then fetch that procestype's resultaten so
|
||||
# both klassen validate against the zaaktype's selectielijstProcestype.
|
||||
procestype = selectielijst("/resultaten?pageSize=1")["results"][0]["procesType"]
|
||||
resultaten = selectielijst(f"/resultaten?procesType={urllib.parse.quote(procestype, safe='')}")["results"]
|
||||
if len(resultaten) < len(wanted):
|
||||
sys.exit(f"selectielijst procestype has too few resultaten ({len(resultaten)}) for {len(wanted)} resultaattypen")
|
||||
resultaat = selectielijst("/resultaten?pageSize=1")["results"][0]
|
||||
omschrijvingen = selectielijst("/resultaattypeomschrijvingen")
|
||||
oms_list = omschrijvingen if isinstance(omschrijvingen, list) else omschrijvingen["results"]
|
||||
|
||||
st, body = api("PATCH", zt["url"], {"selectielijstProcestype": procestype})
|
||||
oms = (omschrijvingen if isinstance(omschrijvingen, list) else omschrijvingen["results"])[0]["url"]
|
||||
# The selectielijstklasse and the zaaktype must share a procestype.
|
||||
st, body = api("PATCH", zt["url"], {"selectielijstProcestype": resultaat["procesType"]})
|
||||
if st != 200:
|
||||
sys.exit(f"set procestype -> {st}: {json.dumps(body, indent=2)}")
|
||||
|
||||
for i, (naam, archiefnominatie) in enumerate(wanted):
|
||||
if naam in have_rt:
|
||||
print(f"skip resultaattype {naam}")
|
||||
continue
|
||||
st, body = api("POST", "/resultaattypen", {
|
||||
"zaaktype": zt["url"], "omschrijving": naam,
|
||||
"resultaattypeomschrijving": oms_list[i]["url"], "selectielijstklasse": resultaten[i]["url"],
|
||||
"archiefnominatie": archiefnominatie,
|
||||
"brondatumArchiefprocedure": {"afleidingswijze": "afgehandeld"},
|
||||
})
|
||||
if st != 201:
|
||||
sys.exit(f"create resultaattype {naam} -> {st}: {json.dumps(body, indent=2)}")
|
||||
print(f"create resultaattype {naam}")
|
||||
st, body = api("POST", "/resultaattypen", {
|
||||
"zaaktype": zt["url"], "omschrijving": "Geregistreerd",
|
||||
"resultaattypeomschrijving": oms, "selectielijstklasse": resultaat["url"],
|
||||
"archiefnominatie": "blijvend_bewaren",
|
||||
"brondatumArchiefprocedure": {"afleidingswijze": "afgehandeld"},
|
||||
})
|
||||
if st != 201:
|
||||
sys.exit(f"create resultaattype -> {st}: {json.dumps(body, indent=2)}")
|
||||
print("create resultaattype Geregistreerd")
|
||||
|
||||
if zt.get("concept", True):
|
||||
st, body = api("POST", f"{zt['url']}/publish")
|
||||
@@ -145,58 +124,6 @@ def publish_zaaktype(zt):
|
||||
print("skip publish (already published)")
|
||||
|
||||
|
||||
def seed_informatieobjecttype(cat, zt):
|
||||
"""Create the "Diploma" informatieobjecttype and relate it to the zaaktype (both idempotent).
|
||||
|
||||
A diploma uploaded in S-10b is filed under this informatieobjecttype; OpenZaak only accepts a
|
||||
document (and its zaak relation) once the informatieobjecttype is published AND allowed for the
|
||||
zaak's zaaktype (a zaaktype-informatieobjecttype relation). Both the relation and this call must run
|
||||
while the zaaktype is still a concept, so seed this *before* publishing the zaaktype. Returns the
|
||||
informatieobjecttype dict.
|
||||
"""
|
||||
iots = [i for i in find(f"/informatieobjecttypen?catalogus={cat['url']}&status=alles")
|
||||
if i.get("omschrijving") == "Diploma"]
|
||||
if iots:
|
||||
iot = iots[0]
|
||||
print(f"skip informatieobjecttype Diploma ({iot['url']}) concept={iot.get('concept')}")
|
||||
else:
|
||||
st, iot = api("POST", "/informatieobjecttypen", {
|
||||
"catalogus": cat["url"],
|
||||
"omschrijving": "Diploma",
|
||||
"vertrouwelijkheidaanduiding": "openbaar",
|
||||
"informatieobjectcategorie": "diploma",
|
||||
"beginGeldigheid": "2026-01-01",
|
||||
})
|
||||
if st != 201:
|
||||
sys.exit(f"create informatieobjecttype -> {st}: {json.dumps(iot, indent=2)}")
|
||||
print(f"create informatieobjecttype Diploma ({iot['url']})")
|
||||
|
||||
# Relate it to the zaaktype (must be done while both are concept).
|
||||
relations = find(f"/zaaktype-informatieobjecttypen?zaaktype={zt['url']}&status=alles")
|
||||
if any(r.get("informatieobjecttype") == iot["url"] for r in relations):
|
||||
print("skip zaaktype-informatieobjecttype Diploma")
|
||||
else:
|
||||
st, body = api("POST", "/zaaktype-informatieobjecttypen", {
|
||||
"zaaktype": zt["url"], "informatieobjecttype": iot["url"],
|
||||
"volgnummer": 1, "richting": "inkomend"})
|
||||
if st != 201:
|
||||
sys.exit(f"relate zaaktype-informatieobjecttype -> {st}: {json.dumps(body, indent=2)}")
|
||||
print("create zaaktype-informatieobjecttype Diploma")
|
||||
|
||||
return iot
|
||||
|
||||
|
||||
def publish_informatieobjecttype(iot):
|
||||
"""Publish the informatieobjecttype (idempotent) so documents may reference it."""
|
||||
if iot.get("concept", True):
|
||||
st, body = api("POST", f"{iot['url']}/publish")
|
||||
if st != 200:
|
||||
sys.exit(f"publish informatieobjecttype -> {st}: {json.dumps(body, indent=2)}")
|
||||
print(f"publish informatieobjecttype Diploma ({iot['url']})")
|
||||
else:
|
||||
print("skip publish informatieobjecttype (already published)")
|
||||
|
||||
|
||||
def main():
|
||||
# 1. Catalogus
|
||||
existing = [c for c in find(f"/catalogussen?domein=BIG") if c.get("domein") == "BIG"]
|
||||
@@ -271,16 +198,10 @@ def main():
|
||||
# schema-mandatory" zaaktype S-01 asks for (ADR-0002). Set OZ_PUBLISH=1 to add
|
||||
# those relations and publish — needed so a real zaak POST is accepted, which
|
||||
# the ACL integration test (S-04a, #46) exercises. See ADR-0006.
|
||||
iot = None
|
||||
if PUBLISH:
|
||||
# Re-fetch: the bsn-eigenschap branch above may hold a stale concept flag.
|
||||
zt = next(z for z in find(f"/zaaktypen?catalogus={cat['url']}&status=alles")
|
||||
if z.get("identificatie") == "BIG-REGISTRATIE")
|
||||
# Seed + relate the Diploma informatieobjecttype (S-10b) while the zaaktype is still concept,
|
||||
# then publish both. Publish the informatieobjecttype before the zaaktype so the zaaktype's
|
||||
# relations reference a published type.
|
||||
iot = seed_informatieobjecttype(cat, zt)
|
||||
publish_informatieobjecttype(iot)
|
||||
publish_zaaktype(zt)
|
||||
|
||||
# 5. Verify the JWT client can list the zaaktype (concepts included).
|
||||
@@ -293,10 +214,6 @@ def main():
|
||||
# zaaktype URL to configure the ACL's default-fill (ADR-0003/0009).
|
||||
zt_url = next(z["url"] for z in zaaktypen if z.get("identificatie") == "BIG-REGISTRATIE")
|
||||
print(f"ZAAKTYPE_URL {zt_url}")
|
||||
# Machine-readable informatieobjecttype URL (S-10b) so callers can configure the ACL's document
|
||||
# default-fill. Only emitted when publishing — a concept informatieobjecttype can't back a document.
|
||||
if iot is not None:
|
||||
print(f"INFORMATIEOBJECTTYPE_URL {iot['url']}")
|
||||
print(f"OK — BIG catalogus seeded (BIG-REGISTRATIE {state} + bsn eigenschap)")
|
||||
|
||||
|
||||
|
||||
+6
-244
@@ -30,18 +30,16 @@ oz_ip="$(ip "$oz")"; dom_ip="$(ip "$dom")"
|
||||
oz_base="http://$oz_ip:8000"
|
||||
echo ">> openzaak=$oz_ip domain=$dom_ip network=$net"
|
||||
|
||||
echo ">> seeding + publishing a BIG zaaktype (idempotent)"
|
||||
echo ">> seeding a published BIG zaaktype (idempotent) and capturing its URL"
|
||||
sid="$(docker create --network "$net" -e "OZ_BASE=$oz_base" -e OZ_PUBLISH=1 python:3-slim python /seed.py)"
|
||||
docker cp "$here/openzaak/seed_catalogus.py" "$sid:/seed.py" >/dev/null
|
||||
seed_out="$(docker start -a "$sid")"
|
||||
zt_url="$(docker start -a "$sid" | sed -n 's/^ZAAKTYPE_URL //p' | head -1)"
|
||||
docker rm -f "$sid" >/dev/null
|
||||
printf '%s\n' "$seed_out" | grep -q '^ZAAKTYPE_URL ' || { echo "ERROR: seed did not publish the zaaktype" >&2; exit 1; }
|
||||
[ -n "$zt_url" ] || { echo "ERROR: seed did not report a ZAAKTYPE_URL" >&2; exit 1; }
|
||||
echo ">> zaaktype: $zt_url"
|
||||
|
||||
# The ACL resolves the zaaktype + informatieobjecttype by identificatie/omschrijving (S-27, ADR-0021),
|
||||
# so there is no URL to inject — only the OpenZaak base URL, pointed at the same host's container IP
|
||||
# (OpenZaak rejects a single-label host on zaak-create).
|
||||
echo ">> recreating the acl service pointed at OpenZaak's IP (it resolves the zaaktype itself, S-27)"
|
||||
ACL_OPENZAAK_BASEURL="$oz_base/" docker compose -f "$compose" up -d acl
|
||||
echo ">> recreating the acl service pointed at the seeded zaaktype (host-consistent)"
|
||||
ACL_ZAAKTYPE_URL="$zt_url" ACL_OPENZAAK_BASEURL="$oz_base/" docker compose -f "$compose" up -d acl
|
||||
WAIT_TIMEOUT="${WAIT_TIMEOUT:-120}" bash "$here/wait-healthy.sh" acl
|
||||
|
||||
echo ">> submitting a registration to the domain"
|
||||
@@ -95,27 +93,6 @@ print(next((t['id'] for t in (d.get('data') or [])
|
||||
|
||||
flcurl() { docker run --rm --network "$net" curlimages/curl:latest -fsS -u rest-admin:test "$@"; }
|
||||
query='{"processDefinitionKey":"registratie","taskDefinitionKey":"Beoordelen","includeProcessVariables":true}'
|
||||
wacht_query='{"processDefinitionKey":"registratie","taskDefinitionKey":"WachtOpDocumenten","includeProcessVariables":true}'
|
||||
|
||||
# S-10a: every registration now parks at WachtOpDocumenten first (interrupting P30D timer). Completing
|
||||
# that task stands in for the citizen's document upload (wired for real in S-10b), letting the process
|
||||
# advance to the diploma routing / Beoordelen so the checks below still hold. The 30-day timeout branch
|
||||
# is exercised separately at the end.
|
||||
complete_wacht() { # reg_id
|
||||
local rid="$1" wid="" r
|
||||
for _ in $(seq 1 30); do
|
||||
r="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$wacht_query" 2>/dev/null || true)"
|
||||
wid="$(printf '%s' "$r" | task_for_reg "$rid")"
|
||||
[ -n "$wid" ] && break
|
||||
sleep 2
|
||||
done
|
||||
[ -n "$wid" ] || { echo "FAIL — no WachtOpDocumenten task appeared for $rid" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
|
||||
flcurl -X POST "$fl_base/runtime/tasks/$wid" -H 'Content-Type: application/json' -d '{"action":"complete"}' >/dev/null
|
||||
echo ">> completed WachtOpDocumenten for $rid (documents received)"
|
||||
}
|
||||
|
||||
echo ">> completing WachtOpDocumenten so the process advances (documents received)"
|
||||
complete_wacht "$reg_id"
|
||||
|
||||
echo ">> polling Flowable for the Beoordelen user task (werkbak)"
|
||||
task_id=""
|
||||
@@ -153,7 +130,6 @@ loc2="$(docker run --rm --network "$net" curlimages/curl:latest \
|
||||
[ -n "$loc2" ] || { echo "FAIL — second POST /registrations returned no Location" >&2; exit 1; }
|
||||
reg_id2="${loc2##*/}"
|
||||
echo ">> second registration $reg_id2"
|
||||
complete_wacht "$reg_id2"
|
||||
|
||||
echo ">> polling Flowable for its Beoordelen task"
|
||||
task_id2=""
|
||||
@@ -181,218 +157,4 @@ for _ in $(seq 1 15); do
|
||||
done
|
||||
[ -n "$gone" ] || { echo "FAIL — Beoordelen task for $reg_id2 still active after withdrawal" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
|
||||
echo "OK — withdrawal cancelled the Beoordelen task; the registratie process ended (ingetrokken)"
|
||||
|
||||
# ── S-13: diploma-eligibility routing. A registration with a FOREIGN diploma must route through the
|
||||
# extra CBGVAdvies user task before Beoordelen (the DMN service task sets route=CBGV_ADVIES and the
|
||||
# gateway branches, ADR-0016). The domestic DIRECT path is already proven by the first registration
|
||||
# above, which parked straight at Beoordelen. ──────────────────────────────────────────────────────
|
||||
cbgv_query='{"processDefinitionKey":"registratie","taskDefinitionKey":"CBGVAdvies","includeProcessVariables":true}'
|
||||
echo ">> submitting a registration with a foreign diploma"
|
||||
locf="$(docker run --rm --network "$net" curlimages/curl:latest \
|
||||
-fsS -D - -o /dev/null -X POST "http://$dom_ip:8080/registrations" \
|
||||
-H 'Content-Type: application/json' -d '{"bsn":"123456782","diplomaOrigin":"Buitenlands"}' \
|
||||
| sed -n 's/\r$//; s/^[Ll]ocation: //p' | head -1)"
|
||||
[ -n "$locf" ] || { echo "FAIL — foreign POST /registrations returned no Location" >&2; exit 1; }
|
||||
reg_idf="${locf##*/}"
|
||||
echo ">> foreign registration $reg_idf"
|
||||
complete_wacht "$reg_idf"
|
||||
|
||||
echo ">> polling Flowable for its CBGV-advies task (foreign diplomas route here first)"
|
||||
cbgv_task=""
|
||||
for _ in $(seq 1 30); do
|
||||
resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$cbgv_query" 2>/dev/null || true)"
|
||||
cbgv_task="$(printf '%s' "$resp" | task_for_reg "$reg_idf")"
|
||||
[ -n "$cbgv_task" ] && break
|
||||
sleep 2
|
||||
done
|
||||
[ -n "$cbgv_task" ] || { echo "FAIL — no CBGVAdvies task appeared for the foreign registration $reg_idf" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
|
||||
echo ">> CBGVAdvies task $cbgv_task is waiting"
|
||||
|
||||
echo ">> asserting it has NOT reached Beoordelen yet (still awaiting CBGV-advies)"
|
||||
resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$query")"
|
||||
early="$(printf '%s' "$resp" | task_for_reg "$reg_idf")"
|
||||
[ -z "$early" ] || { echo "FAIL — foreign registration reached Beoordelen ($early) before CBGV-advies" >&2; exit 1; }
|
||||
|
||||
echo ">> completing the CBGV-advies task"
|
||||
flcurl -X POST "$fl_base/runtime/tasks/$cbgv_task" -H 'Content-Type: application/json' -d '{"action":"complete"}' >/dev/null
|
||||
|
||||
echo ">> asserting it now advances to Beoordelen"
|
||||
onward=""
|
||||
for _ in $(seq 1 15); do
|
||||
resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$query" 2>/dev/null || true)"
|
||||
[ -n "$(printf '%s' "$resp" | task_for_reg "$reg_idf")" ] && { onward=1; break; }
|
||||
sleep 2
|
||||
done
|
||||
[ -n "$onward" ] || { echo "FAIL — foreign registration did not reach Beoordelen after CBGV-advies" >&2; exit 1; }
|
||||
echo "OK — foreign diploma routed through CBGV-advies, then on to Beoordelen (DMN + gateway)"
|
||||
|
||||
# ── S-14: escalation. A third registration parks at Beoordelen. We fire its 14-day boundary timer
|
||||
# early via Flowable's management API (the timer job is moved to executable and run), which routes a
|
||||
# parallel token to the BeoordelingEscaleren external task. The domain's escalation worker acquires
|
||||
# it and reassigns the still-open Beoordelen task from the behandelaar group to teamlead (ADR-0015). ─
|
||||
echo ">> submitting a third registration to escalate"
|
||||
loc3="$(docker run --rm --network "$net" curlimages/curl:latest \
|
||||
-fsS -D - -o /dev/null -X POST "http://$dom_ip:8080/registrations" \
|
||||
-H 'Content-Type: application/json' -d '{"bsn":"123456782"}' \
|
||||
| sed -n 's/\r$//; s/^[Ll]ocation: //p' | head -1)"
|
||||
[ -n "$loc3" ] || { echo "FAIL — third POST /registrations returned no Location" >&2; exit 1; }
|
||||
reg_id3="${loc3##*/}"
|
||||
echo ">> third registration $reg_id3"
|
||||
|
||||
# Extracts "<taskId> <processInstanceId>" for a registration from a task-query response on stdin.
|
||||
task_and_pid_for_reg() { REG_ID="$1" python3 -c "import os,sys,json
|
||||
try:
|
||||
d=json.load(sys.stdin)
|
||||
except Exception:
|
||||
d={}
|
||||
rid=os.environ['REG_ID']
|
||||
t=next((t for t in (d.get('data') or [])
|
||||
if any(v.get('name')=='registrationId' and v.get('value')==rid for v in (t.get('variables') or []))), None)
|
||||
print(f\"{t['id']} {t['processInstanceId']}\" if t else '')"; }
|
||||
|
||||
# The candidate groups on a task (space-separated, sorted) from a runtime identitylinks response.
|
||||
candidate_groups() { python3 -c "import sys,json
|
||||
try:
|
||||
links=json.load(sys.stdin)
|
||||
except Exception:
|
||||
links=[]
|
||||
print(' '.join(sorted(l.get('group') or '' for l in links if l.get('type')=='candidate' and l.get('group'))))"; }
|
||||
|
||||
# The first job id in a management jobs/timer-jobs response on stdin.
|
||||
first_job_id() { python3 -c "import sys,json
|
||||
try:
|
||||
d=json.load(sys.stdin)
|
||||
except Exception:
|
||||
d={}
|
||||
print(((d.get('data') or [{}])[0]).get('id',''))"; }
|
||||
|
||||
complete_wacht "$reg_id3"
|
||||
|
||||
echo ">> polling Flowable for its Beoordelen task"
|
||||
task_id3=""; pid3=""
|
||||
for _ in $(seq 1 30); do
|
||||
resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$query" 2>/dev/null || true)"
|
||||
read -r task_id3 pid3 <<<"$(printf '%s' "$resp" | task_and_pid_for_reg "$reg_id3")"
|
||||
[ -n "$task_id3" ] && break
|
||||
sleep 2
|
||||
done
|
||||
[ -n "$task_id3" ] || { echo "FAIL — no Beoordelen task appeared for registration $reg_id3" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
|
||||
echo ">> Beoordelen task $task_id3 (instance $pid3) is waiting for the behandelaar"
|
||||
|
||||
echo ">> asserting the task starts out claimable by the behandelaar group"
|
||||
before="$(flcurl "$fl_base/runtime/tasks/$task_id3/identitylinks" | candidate_groups)"
|
||||
[ "$before" = "behandelaar" ] || { echo "FAIL — expected candidate group 'behandelaar', got '$before'" >&2; exit 1; }
|
||||
|
||||
echo ">> firing the 14-day boundary timer early via the management API"
|
||||
timer_id="$(flcurl "$fl_base/management/timer-jobs?processInstanceId=$pid3" | first_job_id)"
|
||||
[ -n "$timer_id" ] || { echo "FAIL — no timer job found for instance $pid3" >&2; exit 1; }
|
||||
# Move the timer job to an executable async job. Flowable's async executor (running in flowable-rest)
|
||||
# then picks it up and fires the non-interrupting boundary event. It may run the job before we can
|
||||
# look, so executing it explicitly is a best-effort nudge — tolerate the job already being gone.
|
||||
flcurl -X POST "$fl_base/management/timer-jobs/$timer_id" -H 'Content-Type: application/json' -d '{"action":"move"}' >/dev/null
|
||||
async_id="$(flcurl "$fl_base/management/jobs?processInstanceId=$pid3" 2>/dev/null | first_job_id || true)"
|
||||
if [ -n "$async_id" ]; then
|
||||
flcurl -X POST "$fl_base/management/jobs/$async_id" -H 'Content-Type: application/json' -d '{"action":"execute"}' >/dev/null 2>&1 || true
|
||||
fi
|
||||
echo ">> timer fired; the BeoordelingEscaleren token is parked for the domain worker"
|
||||
|
||||
echo ">> polling until the escalation worker reassigns the beoordeling to the teamlead"
|
||||
escalated=""
|
||||
for _ in $(seq 1 30); do
|
||||
groups="$(flcurl "$fl_base/runtime/tasks/$task_id3/identitylinks" 2>/dev/null | candidate_groups || true)"
|
||||
[ "$groups" = "teamlead" ] && { escalated=1; break; }
|
||||
sleep 2
|
||||
done
|
||||
[ -n "$escalated" ] || { echo "FAIL — Beoordelen task not reassigned to teamlead (candidate groups: '$groups')" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
|
||||
echo "OK — the 14-day timer escalated the still-open Beoordelen task to the teamlead"
|
||||
|
||||
# ── S-10a/S-10c: document timeout. A registration parks at WachtOpDocumenten and — unlike every block
|
||||
# above — its documents never arrive. We fire its 30-day boundary timer early via the management API;
|
||||
# the INTERRUPTING timer cancels the wait and routes a token to the RegistratieVerlopen external task.
|
||||
# The domain's timeout worker acquires it, cancels the ZGW zaak via the ACL (S-10c), and expires the
|
||||
# registration to VERLOPEN (ADR-0017). ─────────────────────────────────────────────────────────────
|
||||
echo ">> submitting a registration to let its document term lapse"
|
||||
locv="$(docker run --rm --network "$net" curlimages/curl:latest \
|
||||
-fsS -D - -o /dev/null -X POST "http://$dom_ip:8080/registrations" \
|
||||
-H 'Content-Type: application/json' -d '{"bsn":"123456782"}' \
|
||||
| sed -n 's/\r$//; s/^[Ll]ocation: //p' | head -1)"
|
||||
[ -n "$locv" ] || { echo "FAIL — timeout POST /registrations returned no Location" >&2; exit 1; }
|
||||
reg_idv="${locv##*/}"
|
||||
echo ">> timeout registration $reg_idv"
|
||||
|
||||
echo ">> polling Flowable for its WachtOpDocumenten task"
|
||||
wacht_id=""; pidv=""
|
||||
for _ in $(seq 1 30); do
|
||||
resp="$(flcurl -X POST "$fl_base/query/tasks" -H 'Content-Type: application/json' -d "$wacht_query" 2>/dev/null || true)"
|
||||
read -r wacht_id pidv <<<"$(printf '%s' "$resp" | task_and_pid_for_reg "$reg_idv")"
|
||||
[ -n "$wacht_id" ] && break
|
||||
sleep 2
|
||||
done
|
||||
[ -n "$wacht_id" ] || { echo "FAIL — no WachtOpDocumenten task appeared for $reg_idv" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
|
||||
echo ">> WachtOpDocumenten task $wacht_id (instance $pidv) is waiting for documents"
|
||||
|
||||
echo ">> firing the 30-day document timer early via the management API"
|
||||
timer_idv="$(flcurl "$fl_base/management/timer-jobs?processInstanceId=$pidv" | first_job_id)"
|
||||
[ -n "$timer_idv" ] || { echo "FAIL — no timer job found for instance $pidv" >&2; exit 1; }
|
||||
# Move the timer job to an executable async job; the async executor fires the interrupting boundary
|
||||
# event. It may run before we look, so executing it explicitly is a best-effort nudge (as for S-14).
|
||||
flcurl -X POST "$fl_base/management/timer-jobs/$timer_idv" -H 'Content-Type: application/json' -d '{"action":"move"}' >/dev/null
|
||||
async_idv="$(flcurl "$fl_base/management/jobs?processInstanceId=$pidv" 2>/dev/null | first_job_id || true)"
|
||||
if [ -n "$async_idv" ]; then
|
||||
flcurl -X POST "$fl_base/management/jobs/$async_idv" -H 'Content-Type: application/json' -d '{"action":"execute"}' >/dev/null 2>&1 || true
|
||||
fi
|
||||
echo ">> timer fired; the RegistratieVerlopen token is parked for the domain worker"
|
||||
|
||||
echo ">> polling the domain until the timeout worker expires the registration to VERLOPEN"
|
||||
verlopen=""
|
||||
for _ in $(seq 1 30); do
|
||||
body="$(docker run --rm --network "$net" curlimages/curl:latest -fsS "http://$dom_ip:8080$locv" 2>/dev/null || true)"
|
||||
printf '%s' "$body" | grep -qi 'verlopen' && { verlopen=1; break; }
|
||||
sleep 2
|
||||
done
|
||||
[ -n "$verlopen" ] || { echo "FAIL — registration $reg_idv not VERLOPEN after the document timer fired (body: $body)" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
|
||||
echo "OK — the 30-day document timer expired the registration to VERLOPEN"
|
||||
|
||||
# S-10c: the worker cancels the ZGW zaak (ACL-first, before it expires the aggregate), so a VERLOPEN
|
||||
# registration must carry a zaak whose current status is "Geannuleerd". Read it back from OpenZaak with
|
||||
# a ZGW token minted like the seed's client (the same client OpenZaak trusts for this stack).
|
||||
zaak_url_v="$(printf '%s' "$body" | grep -oiE 'http://[^"]*/zaken/api/v1/zaken/[a-f0-9-]+' | head -1)"
|
||||
[ -n "$zaak_url_v" ] || { echo "FAIL — VERLOPEN registration $reg_idv exposes no zaak URL (body: $body)" >&2; exit 1; }
|
||||
echo ">> confirming the zaak $zaak_url_v reached the Geannuleerd status in OpenZaak"
|
||||
|
||||
read_zaak_status() {
|
||||
# -i so the heredoc reaches `python -` on the container's stdin (without it the script is empty).
|
||||
docker run --rm -i --network "$net" \
|
||||
-e OZ_CLIENT_ID="${OZ_CLIENT_ID:-big-reference-seed}" \
|
||||
-e OZ_SECRET="${OZ_SECRET:-insecure-dev-secret-change-me}" \
|
||||
python:3-slim python - "$1" <<'PY'
|
||||
import base64, hashlib, hmac, json, os, sys, time, urllib.request
|
||||
cid, sec = os.environ["OZ_CLIENT_ID"], os.environ["OZ_SECRET"]
|
||||
b64 = lambda b: base64.urlsafe_b64encode(b).rstrip(b"=")
|
||||
def token():
|
||||
hdr = {"alg": "HS256", "typ": "JWT"}
|
||||
pl = {"iss": cid, "iat": int(time.time()), "client_id": cid, "user_id": "verify", "user_representation": "verify"}
|
||||
seg = b64(json.dumps(hdr, separators=(",", ":")).encode()) + b"." + b64(json.dumps(pl, separators=(",", ":")).encode())
|
||||
return (seg + b"." + b64(hmac.new(sec.encode(), seg, hashlib.sha256).digest())).decode()
|
||||
def get(url):
|
||||
req = urllib.request.Request(url, headers={
|
||||
"Authorization": "Bearer " + token(), "Accept": "application/json", "Accept-Crs": "EPSG:4326"})
|
||||
with urllib.request.urlopen(req, timeout=30) as r:
|
||||
return json.loads(r.read())
|
||||
zaak = get(sys.argv[1])
|
||||
status_url = zaak.get("status")
|
||||
if not status_url:
|
||||
print(""); sys.exit(0)
|
||||
print(get(get(status_url)["statustype"]).get("omschrijving", ""))
|
||||
PY
|
||||
}
|
||||
|
||||
geannuleerd=""
|
||||
for _ in $(seq 1 15); do
|
||||
oms="$(read_zaak_status "$zaak_url_v" 2>/dev/null | tr -d '\r' || true)"
|
||||
[ "$oms" = "Geannuleerd" ] && { geannuleerd=1; break; }
|
||||
sleep 2
|
||||
done
|
||||
[ -n "$geannuleerd" ] || { echo "FAIL — zaak $zaak_url_v not Geannuleerd after timeout (current status omschrijving: '$oms')" >&2; docker logs "$dom" 2>&1 | tail -15 >&2; exit 1; }
|
||||
echo "OK — the timed-out registration's zaak was cancelled to Geannuleerd in OpenZaak"
|
||||
exit 0
|
||||
|
||||
@@ -1,67 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
#
|
||||
# Acceptance check for the local stack (S-B04, #110): a fresh `make local` must complete the whole
|
||||
# flow with NO manual seeding. Run against an already-up local stack (infra/docker-compose.local.yml)
|
||||
# via the host-published ports. It exercises, and thereby covers, the three bring-up gaps the slice
|
||||
# fixes:
|
||||
#
|
||||
# 1. zaaktype seeded + ACL wired -> a submitted registration opens a zaak (zaakUrl gets filled).
|
||||
# 2. diploma-eligibility DMN deployed -> providing documents completes WachtOpDocumenten, routes
|
||||
# through the DMN, and the case lands on Beoordelen (visible in the behandel werkbak).
|
||||
# 3. NRC abonnement registered -> the zaak shows up in the openbaar (public) register.
|
||||
#
|
||||
# Before the fix this fails at step 1 (ACL points at a placeholder zaaktype -> OpenZaak 400).
|
||||
set -euo pipefail
|
||||
|
||||
DOM=${DOM:-http://localhost:8130} # domain
|
||||
BFF=${BFF:-http://localhost:8080} # bff (openbaar register)
|
||||
BSN=${BSN:-123456782}
|
||||
# A minimal, valid PDF, base64-encoded (the diploma upload).
|
||||
PDF_B64="$(printf '%%PDF-1.4\n1 0 obj<</Type/Catalog>>endobj\ntrailer<</Root 1 0 R>>\n%%%%EOF\n' | base64 | tr -d '\n')"
|
||||
|
||||
echo ">> 1. submit a registration (no manual seeding expected)"
|
||||
loc="$(curl -fsS -D - -o /dev/null -X POST "$DOM/registrations" \
|
||||
-H 'Content-Type: application/json' -d "{\"bsn\":\"$BSN\"}" \
|
||||
| sed -n 's/\r$//; s/^[Ll]ocation: //p' | head -1)"
|
||||
[ -n "$loc" ] || { echo "FAIL: POST /registrations returned no Location" >&2; exit 1; }
|
||||
id="${loc##*/}"
|
||||
echo " accepted: $id"
|
||||
|
||||
echo ">> 2. poll until the ACL opens the zaak (proves the zaaktype is seeded + wired)"
|
||||
zaak=""
|
||||
for _ in $(seq 1 30); do
|
||||
zaak="$(curl -fsS "$DOM$loc" | python3 -c 'import sys,json;print(json.load(sys.stdin).get("zaakUrl") or "")' 2>/dev/null || true)"
|
||||
[ -n "$zaak" ] && break
|
||||
sleep 3
|
||||
done
|
||||
[ -n "$zaak" ] || { echo "FAIL: zaak never opened — ACL zaaktype not wired (gap 1)" >&2; exit 1; }
|
||||
echo " zaak opened: $zaak"
|
||||
|
||||
echo ">> 3. provide documents (proves the diploma-eligibility DMN is deployed)"
|
||||
code="$(curl -s -o /dev/null -w '%{http_code}' -X POST "$DOM/registrations/$id/documents" \
|
||||
-H 'Content-Type: application/json' \
|
||||
-d "{\"bsn\":\"$BSN\",\"contentBase64\":\"$PDF_B64\",\"fileName\":\"diploma.pdf\",\"contentType\":\"application/pdf\"}")"
|
||||
[ "$code" = "204" ] || { echo "FAIL: provide documents -> $code (DMN missing routes WachtOpDocumenten to a 404 — gap 2)" >&2; exit 1; }
|
||||
echo " documents accepted (204)"
|
||||
|
||||
echo ">> 4. poll the werkbak until the registration awaits beoordeling (reached Beoordelen)"
|
||||
in_werkbak=""
|
||||
for _ in $(seq 1 20); do
|
||||
in_werkbak="$(curl -fsS "$DOM/behandel/werkbak" | python3 -c "import sys,json;print(any(r.get('registrationId')=='$id' for r in json.load(sys.stdin)))" 2>/dev/null || true)"
|
||||
[ "$in_werkbak" = "True" ] && break
|
||||
sleep 3
|
||||
done
|
||||
[ "$in_werkbak" = "True" ] || { echo "FAIL: registration never reached the werkbak (gap 2)" >&2; exit 1; }
|
||||
echo " in the werkbak"
|
||||
|
||||
echo ">> 5. poll the openbaar register until the reference is publicly visible (proves NRC abonnement)"
|
||||
public=""
|
||||
for _ in $(seq 1 30); do
|
||||
public="$(curl -fsS "$BFF/openbaar/register" | python3 -c "import sys,json;print(any(r.get('reference')=='$id' for r in json.load(sys.stdin)))" 2>/dev/null || true)"
|
||||
[ "$public" = "True" ] && break
|
||||
sleep 3
|
||||
done
|
||||
[ "$public" = "True" ] || { echo "FAIL: reference never appeared in the openbaar register — NRC abonnement not registered (gap 3)" >&2; exit 1; }
|
||||
echo " visible in the openbaar register"
|
||||
|
||||
echo "OK — a fresh local stack completed the flow with no manual seeding (zaaktype + DMN + abonnement)"
|
||||
+1
-10
@@ -35,21 +35,12 @@ populate() { # volume source(file or dir/.)
|
||||
|
||||
[ "$#" -gt 0 ] || { echo "usage: seed-config.sh <oz|nrc|kc|fl> ..." >&2; exit 2; }
|
||||
|
||||
# The registratie process (BPMN) and its diploma-eligibility DMN are deployed as SEPARATE Flowable
|
||||
# deployments — the process engine and the DMN engine each own theirs (S-13, ADR-0016). flowable-rest
|
||||
# does not cascade a .dmn bundled in a process .bar into the DMN engine, so we seed both raw files and
|
||||
# let flowable-init deploy each via its own REST app. We stage them in a temp dir and copy its contents.
|
||||
stage_flowable_workflows() {
|
||||
local dir="$1"
|
||||
cp "$here/../workflows/registratie.bpmn" "$here/../workflows/diploma-eligibility.dmn" "$dir/"
|
||||
}
|
||||
|
||||
for key in "$@"; do
|
||||
case "$key" in
|
||||
oz) populate rr-oz-config "$here/openzaak/setup_configuration/." ;;
|
||||
nrc) populate rr-nrc-config "$here/opennotificaties/setup_configuration/." ;;
|
||||
kc) populate rr-kc-realms "$here/keycloak/realms/." ;;
|
||||
fl) d="$(mktemp -d)"; stage_flowable_workflows "$d"; populate rr-fl-bpmn "$d/." ;;
|
||||
fl) populate rr-fl-bpmn "$here/../workflows/registratie.bpmn" ;;
|
||||
*) echo "unknown seed key: $key" >&2; exit 2 ;;
|
||||
esac
|
||||
done
|
||||
|
||||
@@ -24,11 +24,6 @@ import {
|
||||
Observable
|
||||
} from 'rxjs';
|
||||
|
||||
export interface CurrentRegistration {
|
||||
registrationId: string;
|
||||
status: string;
|
||||
}
|
||||
|
||||
export interface DecideRequest {
|
||||
besluit: string;
|
||||
}
|
||||
@@ -40,14 +35,6 @@ export interface OpenbaarEntry {
|
||||
reference: string | null;
|
||||
}
|
||||
|
||||
export interface ProvideDocumentsRequest {
|
||||
contentBase64: string;
|
||||
/** @nullable */
|
||||
fileName?: string | null;
|
||||
/** @nullable */
|
||||
contentType?: string | null;
|
||||
}
|
||||
|
||||
export interface SubmitAccepted {
|
||||
registrationId: string;
|
||||
status: string;
|
||||
@@ -205,37 +192,6 @@ export class BffApiV1Service {
|
||||
);
|
||||
}
|
||||
|
||||
getSelfServiceRegistrations<TData = CurrentRegistration | void>( options?: HttpClientBodyOptions): Observable<TData>;
|
||||
getSelfServiceRegistrations<TData = CurrentRegistration | void>( options?: HttpClientEventOptions): Observable<HttpEvent<TData>>;
|
||||
getSelfServiceRegistrations<TData = CurrentRegistration | void>( options?: HttpClientResponseOptions): Observable<AngularHttpResponse<TData>>;
|
||||
getSelfServiceRegistrations<TData = CurrentRegistration | void>(
|
||||
options?: HttpClientObserveOptions): Observable<TData | HttpEvent<TData> | AngularHttpResponse<TData>> {
|
||||
if (options?.observe === 'events') {
|
||||
return this.http.get<TData>(
|
||||
`/self-service/registrations`,{
|
||||
...(options as Omit<NonNullable<typeof options>, 'observe'>),
|
||||
observe: 'events',
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
if (options?.observe === 'response') {
|
||||
return this.http.get<TData>(
|
||||
`/self-service/registrations`,{
|
||||
...(options as Omit<NonNullable<typeof options>, 'observe'>),
|
||||
observe: 'response',
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
return this.http.get<TData>(
|
||||
`/self-service/registrations`,{
|
||||
...(options as Omit<NonNullable<typeof options>, 'observe'>),
|
||||
observe: 'body',
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
postSelfServiceRegistrationsIdWithdraw<TData = void>(id: string, options?: HttpClientBodyOptions): Observable<TData>;
|
||||
postSelfServiceRegistrationsIdWithdraw<TData = void>(id: string, options?: HttpClientEventOptions): Observable<HttpEvent<TData>>;
|
||||
postSelfServiceRegistrationsIdWithdraw<TData = void>(id: string, options?: HttpClientResponseOptions): Observable<AngularHttpResponse<TData>>;
|
||||
@@ -270,44 +226,6 @@ export class BffApiV1Service {
|
||||
);
|
||||
}
|
||||
|
||||
postSelfServiceRegistrationsIdDocuments<TData = void>(id: string,
|
||||
provideDocumentsRequest: ProvideDocumentsRequest, options?: HttpClientBodyOptions): Observable<TData>;
|
||||
postSelfServiceRegistrationsIdDocuments<TData = void>(id: string,
|
||||
provideDocumentsRequest: ProvideDocumentsRequest, options?: HttpClientEventOptions): Observable<HttpEvent<TData>>;
|
||||
postSelfServiceRegistrationsIdDocuments<TData = void>(id: string,
|
||||
provideDocumentsRequest: ProvideDocumentsRequest, options?: HttpClientResponseOptions): Observable<AngularHttpResponse<TData>>;
|
||||
postSelfServiceRegistrationsIdDocuments<TData = void>(
|
||||
id: string,
|
||||
provideDocumentsRequest: ProvideDocumentsRequest, options?: HttpClientObserveOptions): Observable<TData | HttpEvent<TData> | AngularHttpResponse<TData>> {
|
||||
if (options?.observe === 'events') {
|
||||
return this.http.post<TData>(
|
||||
`/self-service/registrations/${id}/documents`,
|
||||
provideDocumentsRequest,{
|
||||
...(options as Omit<NonNullable<typeof options>, 'observe'>),
|
||||
observe: 'events',
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
if (options?.observe === 'response') {
|
||||
return this.http.post<TData>(
|
||||
`/self-service/registrations/${id}/documents`,
|
||||
provideDocumentsRequest,{
|
||||
...(options as Omit<NonNullable<typeof options>, 'observe'>),
|
||||
observe: 'response',
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
return this.http.post<TData>(
|
||||
`/self-service/registrations/${id}/documents`,
|
||||
provideDocumentsRequest,{
|
||||
...(options as Omit<NonNullable<typeof options>, 'observe'>),
|
||||
observe: 'body',
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
getOpenbaarRegister<TData = OpenbaarEntry[]>(params?: GetOpenbaarRegisterParams, options?: HttpClientBodyOptions): Observable<TData>;
|
||||
getOpenbaarRegister<TData = OpenbaarEntry[]>(params?: GetOpenbaarRegisterParams, options?: HttpClientEventOptions): Observable<HttpEvent<TData>>;
|
||||
getOpenbaarRegister<TData = OpenbaarEntry[]>(params?: GetOpenbaarRegisterParams, options?: HttpClientResponseOptions): Observable<AngularHttpResponse<TData>>;
|
||||
|
||||
@@ -11,8 +11,6 @@ builder.Services.AddSingleton(sp => sp.GetRequiredService<IConfiguration>()
|
||||
.GetSection("Acl:OpenZaak").Get<OpenZaakOptions>()
|
||||
?? throw new InvalidOperationException("Missing configuration section 'Acl:OpenZaak'"));
|
||||
builder.Services.AddHttpClient<IZaakGateway, OpenZaakGateway>();
|
||||
// Singleton so the resolved zaaktype/informatieobjecttype URLs are cached across requests (S-27).
|
||||
builder.Services.AddSingleton<IZaaktypeCatalog, CachedZaaktypeCatalog>();
|
||||
builder.Services.AddScoped<AclService>();
|
||||
|
||||
var app = builder.Build();
|
||||
@@ -34,14 +32,6 @@ app.MapPost("/statussen", async (SetStatusRequest body, AclService acl, Cancella
|
||||
return Results.NoContent();
|
||||
});
|
||||
|
||||
// Cancel a zaak on document-timeout expiry (S-10c): set it to its zaaktype's cancellation statustype
|
||||
// + resultaat. The domain hands over only the zaak URL; the ACL owns the ZGW resolution (§8.1).
|
||||
app.MapPost("/annuleringen", async (CancelZaakRequest body, AclService acl, CancellationToken ct) =>
|
||||
{
|
||||
await acl.CancelZaakAsync(new Uri(body.ZaakUrl), ct);
|
||||
return Results.NoContent();
|
||||
});
|
||||
|
||||
// Read a zaak's public-safe reference (its identificatie). The Event Subscriber calls this to enrich
|
||||
// the read projection without reading ZGW itself (§8.1, #78).
|
||||
app.MapPost("/zaken/reference", async (ZaakReferenceRequest body, AclService acl, CancellationToken ct) =>
|
||||
@@ -50,25 +40,12 @@ app.MapPost("/zaken/reference", async (ZaakReferenceRequest body, AclService acl
|
||||
return Results.Ok(new { reference });
|
||||
});
|
||||
|
||||
// Store an uploaded diploma against a zaak (S-10b): the domain sends the file as base64; the ACL
|
||||
// creates the ZGW enkelvoudiginformatieobject and relates it to the zaak (§8.1). Returns its URL.
|
||||
app.MapPost("/documenten", async (StoreDocumentRequest body, AclService acl, CancellationToken ct) =>
|
||||
{
|
||||
var url = await acl.StoreDiplomaAsync(
|
||||
new Uri(body.ZaakUrl), Convert.FromBase64String(body.ContentBase64), body.FileName, body.ContentType, ct);
|
||||
return Results.Ok(new { informatieobjectUrl = url.ToString() });
|
||||
});
|
||||
|
||||
app.Run();
|
||||
|
||||
public sealed record OpenZaakRequest(string Bsn, string Reference);
|
||||
|
||||
public sealed record SetStatusRequest(string ZaakUrl);
|
||||
|
||||
public sealed record CancelZaakRequest(string ZaakUrl);
|
||||
|
||||
public sealed record ZaakReferenceRequest(string ZaakUrl);
|
||||
|
||||
public sealed record StoreDocumentRequest(string ZaakUrl, string ContentBase64, string FileName, string ContentType);
|
||||
|
||||
public partial class Program;
|
||||
|
||||
@@ -6,12 +6,5 @@ public sealed class AclDefaults
|
||||
public required string Bronorganisatie { get; init; }
|
||||
public required string VerantwoordelijkeOrganisatie { get; init; }
|
||||
public required string Vertrouwelijkheidaanduiding { get; init; }
|
||||
|
||||
/// <summary>The BIG zaaktype's stable business key. The ACL resolves the (server-assigned) zaaktype
|
||||
/// URL from this via the Catalogi API instead of being handed a pinned URL (S-27, ADR-0021).</summary>
|
||||
public required string ZaaktypeIdentificatie { get; init; }
|
||||
|
||||
/// <summary>The omschrijving of the informatieobjecttype an uploaded diploma is filed under (S-10b);
|
||||
/// resolved to a URL by the Catalogi API, like <see cref="ZaaktypeIdentificatie"/>.</summary>
|
||||
public required string InformatieobjecttypeOmschrijving { get; init; }
|
||||
public required Uri ZaaktypeUrl { get; init; }
|
||||
}
|
||||
|
||||
@@ -2,9 +2,9 @@ namespace Acl.Application;
|
||||
|
||||
/// <summary>The ACL's single operation: open a zaak from a domain payload,
|
||||
/// default-filling the ZGW-mandatory fields (ADR-0003).</summary>
|
||||
public sealed class AclService(IZaakGateway gateway, AclDefaults defaults, IZaaktypeCatalog catalog, IClock clock)
|
||||
public sealed class AclService(IZaakGateway gateway, AclDefaults defaults, IClock clock)
|
||||
{
|
||||
public async Task<Uri> OpenZaakAsync(DomainRegistration registration, CancellationToken ct = default)
|
||||
public Task<Uri> OpenZaakAsync(DomainRegistration registration, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(registration);
|
||||
|
||||
@@ -12,34 +12,22 @@ public sealed class AclService(IZaakGateway gateway, AclDefaults defaults, IZaak
|
||||
defaults.Bronorganisatie,
|
||||
defaults.VerantwoordelijkeOrganisatie,
|
||||
defaults.Vertrouwelijkheidaanduiding,
|
||||
await catalog.GetZaaktypeUrlAsync(ct),
|
||||
defaults.ZaaktypeUrl,
|
||||
clock.Today,
|
||||
registration.Reference);
|
||||
|
||||
return await gateway.OpenZaakAsync(request, ct);
|
||||
return gateway.OpenZaakAsync(request, ct);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Approve a zaak: set it to the eindstatus of the BIG zaaktype (resolved by identificatie, S-27).
|
||||
/// The domain hands over only the zaak URL; the ACL owns which statustype means "approved" (§8.1).
|
||||
/// Approve a zaak: set it to the eindstatus of the configured BIG zaaktype (ADR-0003 default). The
|
||||
/// domain hands over only the zaak URL; the ACL owns which statustype means "approved" (§8.1).
|
||||
/// </summary>
|
||||
public async Task ApproveZaakAsync(Uri zaakUrl, CancellationToken ct = default)
|
||||
public Task ApproveZaakAsync(Uri zaakUrl, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(zaakUrl);
|
||||
|
||||
await gateway.SetZaakToEindstatusAsync(zaakUrl, await catalog.GetZaaktypeUrlAsync(ct), clock.Today, ct);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Cancel a zaak on document-timeout expiry (S-10c): set it to the BIG zaaktype's cancellation
|
||||
/// statustype + resultaat. The domain hands over only the zaak URL; the ACL owns which
|
||||
/// statustype/resultaat means "cancelled" (§8.1).
|
||||
/// </summary>
|
||||
public async Task CancelZaakAsync(Uri zaakUrl, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(zaakUrl);
|
||||
|
||||
await gateway.SetZaakToCancellationStatusAsync(zaakUrl, await catalog.GetZaaktypeUrlAsync(ct), clock.Today, ct);
|
||||
return gateway.SetZaakToEindstatusAsync(zaakUrl, defaults.ZaaktypeUrl, clock.Today, ct);
|
||||
}
|
||||
|
||||
/// <summary>The zaak's reference (its ZGW identificatie), for the read projection (#78).</summary>
|
||||
@@ -49,33 +37,4 @@ public sealed class AclService(IZaakGateway gateway, AclDefaults defaults, IZaak
|
||||
|
||||
return gateway.GetZaakIdentificatieAsync(zaakUrl, ct);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Store an uploaded diploma against the zaak (S-10b): default-fill the ZGW-mandatory document
|
||||
/// fields (informatieobjecttype, bronorganisatie, vertrouwelijkheidaanduiding, taal, creatiedatum)
|
||||
/// and hand the file to the gateway, which creates the informatieobject and relates it to the zaak.
|
||||
/// The domain supplies only the zaak, the bytes, and the file's name/type (§8.1).
|
||||
/// </summary>
|
||||
public async Task<Uri> StoreDiplomaAsync(Uri zaakUrl, byte[] content, string fileName, string contentType, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(zaakUrl);
|
||||
ArgumentNullException.ThrowIfNull(content);
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(fileName);
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(contentType);
|
||||
|
||||
var request = new DocumentRequest(
|
||||
defaults.Bronorganisatie,
|
||||
await catalog.GetInformatieobjecttypeUrlAsync(ct),
|
||||
defaults.Vertrouwelijkheidaanduiding,
|
||||
zaakUrl,
|
||||
clock.Today,
|
||||
Titel: "Diploma",
|
||||
Auteur: "zorgprofessional",
|
||||
Taal: "nld",
|
||||
Bestandsnaam: fileName,
|
||||
Formaat: contentType,
|
||||
Inhoud: content);
|
||||
|
||||
return await gateway.StoreDocumentAsync(request, ct);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,46 +0,0 @@
|
||||
namespace Acl.Application;
|
||||
|
||||
/// <summary>Resolves the zaaktype + diploma-informatieobjecttype URLs from the Catalogi API on first
|
||||
/// use and caches them for the process lifetime (S-27, ADR-0021). Lazy (not at startup) so the ACL
|
||||
/// never crash-loops when it boots before the catalogus is seeded/published; a <em>failed</em>
|
||||
/// resolution is not cached, so it is retried on the next call (e.g. once the zaaktype is published).
|
||||
/// A process restart re-resolves.</summary>
|
||||
public sealed class CachedZaaktypeCatalog(IZaakGateway gateway, AclDefaults defaults) : IZaaktypeCatalog
|
||||
{
|
||||
private readonly SemaphoreSlim gate = new(1, 1);
|
||||
private Uri? zaaktype;
|
||||
private Uri? informatieobjecttype;
|
||||
|
||||
public Task<Uri> GetZaaktypeUrlAsync(CancellationToken ct = default) =>
|
||||
ResolveOnceAsync(
|
||||
() => zaaktype, value => zaaktype = value,
|
||||
() => gateway.ResolveZaaktypeUrlAsync(defaults.ZaaktypeIdentificatie, ct), ct);
|
||||
|
||||
public Task<Uri> GetInformatieobjecttypeUrlAsync(CancellationToken ct = default) =>
|
||||
ResolveOnceAsync(
|
||||
() => informatieobjecttype, value => informatieobjecttype = value,
|
||||
() => gateway.ResolveInformatieobjecttypeUrlAsync(defaults.InformatieobjecttypeOmschrijving, ct), ct);
|
||||
|
||||
// Double-checked, single-flight resolution: return the cache if set; otherwise resolve under the
|
||||
// gate and cache only on success (a throw leaves the cache empty so the next call retries).
|
||||
private async Task<Uri> ResolveOnceAsync(Func<Uri?> read, Action<Uri> store, Func<Task<Uri>> resolve, CancellationToken ct)
|
||||
{
|
||||
if (read() is { } cached)
|
||||
return cached;
|
||||
|
||||
await gate.WaitAsync(ct);
|
||||
try
|
||||
{
|
||||
if (read() is { } existing)
|
||||
return existing;
|
||||
|
||||
var resolved = await resolve();
|
||||
store(resolved);
|
||||
return resolved;
|
||||
}
|
||||
finally
|
||||
{
|
||||
gate.Release();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
namespace Acl.Application;
|
||||
|
||||
/// <summary>The fully default-filled diploma document the gateway will create in the ZGW Documenten
|
||||
/// API and relate to the zaak (S-10b). <see cref="Inhoud"/> is the raw file content; the gateway
|
||||
/// base64-encodes it into the ZGW <c>inhoud</c> field.</summary>
|
||||
public sealed record DocumentRequest(
|
||||
string Bronorganisatie,
|
||||
Uri Informatieobjecttype,
|
||||
string Vertrouwelijkheidaanduiding,
|
||||
Uri Zaak,
|
||||
DateOnly Creatiedatum,
|
||||
string Titel,
|
||||
string Auteur,
|
||||
string Taal,
|
||||
string Bestandsnaam,
|
||||
string Formaat,
|
||||
byte[] Inhoud);
|
||||
@@ -13,31 +13,7 @@ public interface IZaakGateway
|
||||
/// </summary>
|
||||
Task SetZaakToEindstatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default);
|
||||
|
||||
/// <summary>
|
||||
/// Set the given zaak to the <em>cancellation</em> statustype ("Geannuleerd") and record the
|
||||
/// matching cancellation resultaat ("Vervallen") — the ZGW translation of "the 30-day document term
|
||||
/// lapsed" (S-10c). Distinct from <see cref="SetZaakToEindstatusAsync"/> (approval): the gateway
|
||||
/// resolves both the cancellation statustype and resultaattype from the catalogus by their
|
||||
/// omschrijving, POSTs the resultaat then the status, dated <paramref name="datumStatusGezet"/>.
|
||||
/// </summary>
|
||||
Task SetZaakToCancellationStatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default);
|
||||
|
||||
/// <summary>Read the zaak's <c>identificatie</c> — the public-safe reference the register shows.
|
||||
/// The Event Subscriber calls this through the ACL rather than reading ZGW itself (§8.1, #78).</summary>
|
||||
Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default);
|
||||
|
||||
/// <summary>
|
||||
/// Store a diploma document (S-10b): create an <c>enkelvoudiginformatieobject</c> in the ZGW
|
||||
/// Documenten API and relate it to the zaak via a <c>zaakinformatieobject</c>. Returns the URL of
|
||||
/// the created informatieobject.
|
||||
/// </summary>
|
||||
Task<Uri> StoreDocumentAsync(DocumentRequest request, CancellationToken ct = default);
|
||||
|
||||
/// <summary>Resolve the URL of the published zaaktype with the given <paramref name="identificatie"/>
|
||||
/// from the Catalogi API (S-27). Throws if no published zaaktype matches.</summary>
|
||||
Task<Uri> ResolveZaaktypeUrlAsync(string identificatie, CancellationToken ct = default);
|
||||
|
||||
/// <summary>Resolve the URL of the published informatieobjecttype with the given
|
||||
/// <paramref name="omschrijving"/> from the Catalogi API (S-27). Throws if none matches.</summary>
|
||||
Task<Uri> ResolveInformatieobjecttypeUrlAsync(string omschrijving, CancellationToken ct = default);
|
||||
}
|
||||
|
||||
@@ -1,12 +0,0 @@
|
||||
namespace Acl.Application;
|
||||
|
||||
/// <summary>Supplies the ACL's zaaktype + diploma-informatieobjecttype URLs, resolved from OpenZaak's
|
||||
/// Catalogi API by their stable business keys (<see cref="AclDefaults.ZaaktypeIdentificatie"/> /
|
||||
/// <see cref="AclDefaults.InformatieobjecttypeOmschrijving"/>) rather than pinned in config (S-27,
|
||||
/// ADR-0021). Implementations resolve lazily on first use and cache the result.</summary>
|
||||
public interface IZaaktypeCatalog
|
||||
{
|
||||
Task<Uri> GetZaaktypeUrlAsync(CancellationToken ct = default);
|
||||
|
||||
Task<Uri> GetInformatieobjecttypeUrlAsync(CancellationToken ct = default);
|
||||
}
|
||||
@@ -8,12 +8,6 @@ namespace Acl.Infrastructure;
|
||||
/// <summary>The only code that talks to OpenZaak's Zaken API (ADR-0001).</summary>
|
||||
public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) : IZaakGateway
|
||||
{
|
||||
// The ACL owns which ZGW statustype/resultaat carries each domain outcome (§8.1). These
|
||||
// omschrijvingen match the seeded BIG catalogus (infra/openzaak/seed_catalogus.py).
|
||||
private const string GeregistreerdResultaat = "Geregistreerd"; // approval outcome
|
||||
private const string GeannuleerdStatus = "Geannuleerd"; // document-timeout cancellation status (S-10c)
|
||||
private const string VervallenResultaat = "Vervallen"; // document-timeout cancellation outcome (S-10c)
|
||||
|
||||
public async Task<Uri> OpenZaakAsync(ZaakRequest request, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(request);
|
||||
@@ -54,9 +48,7 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
|
||||
ArgumentNullException.ThrowIfNull(zaaktypeUrl);
|
||||
|
||||
var eindstatus = await ResolveEindstatusAsync(zaaktypeUrl, ct);
|
||||
// Resolve the approval resultaat by name: once S-10c adds the Vervallen resultaattype, taking
|
||||
// the first would be ambiguous (the Zaken API does not guarantee order).
|
||||
var resultaattype = await ResolveResultaattypeByOmschrijvingAsync(zaaktypeUrl, GeregistreerdResultaat, ct);
|
||||
var resultaattype = await ResolveResultaattypeAsync(zaaktypeUrl, ct);
|
||||
|
||||
// OpenZaak refuses to set a zaak's eindstatus unless the zaak has a resultaat
|
||||
// ("resultaat-does-not-exist"), so record the resultaat first, then the status.
|
||||
@@ -70,27 +62,6 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
|
||||
"Setting the zaak status", ct);
|
||||
}
|
||||
|
||||
public async Task SetZaakToCancellationStatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(zaakUrl);
|
||||
ArgumentNullException.ThrowIfNull(zaaktypeUrl);
|
||||
|
||||
// Distinct from approval: resolve the cancellation statustype + resultaat by name (Geannuleerd
|
||||
// is a non-terminal statustype, so it is never the eindstatus the approval path resolves).
|
||||
var cancellationStatus = await ResolveStatustypeByOmschrijvingAsync(zaaktypeUrl, GeannuleerdStatus, ct);
|
||||
var cancellationResultaat = await ResolveResultaattypeByOmschrijvingAsync(zaaktypeUrl, VervallenResultaat, ct);
|
||||
|
||||
// As with approval, OpenZaak wants the resultaat recorded before the status.
|
||||
await PostAsync("/zaken/api/v1/resultaten",
|
||||
new ResultaatDto(zaakUrl.ToString(), cancellationResultaat.ToString()),
|
||||
"Setting the zaak cancellation resultaat", ct);
|
||||
|
||||
await PostAsync("/zaken/api/v1/statussen",
|
||||
new StatusDto(zaakUrl.ToString(), cancellationStatus.ToString(),
|
||||
datumStatusGezet.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc).ToString("yyyy-MM-ddTHH:mm:ssZ")),
|
||||
"Setting the zaak cancellation status", ct);
|
||||
}
|
||||
|
||||
public async Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(zaakUrl);
|
||||
@@ -109,81 +80,6 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
|
||||
return zaak.Identificatie;
|
||||
}
|
||||
|
||||
public async Task<Uri> StoreDocumentAsync(DocumentRequest request, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(request);
|
||||
|
||||
// 1. Create the enkelvoudiginformatieobject in the Documenten API (not a geo API — no CRS).
|
||||
var created = await PostForUrlAsync(
|
||||
"/documenten/api/v1/enkelvoudiginformatieobjecten",
|
||||
new EnkelvoudigInformatieobjectDto(
|
||||
request.Bronorganisatie,
|
||||
request.Creatiedatum.ToString("yyyy-MM-dd"),
|
||||
request.Titel,
|
||||
request.Auteur,
|
||||
request.Taal,
|
||||
request.Informatieobjecttype.ToString(),
|
||||
Convert.ToBase64String(request.Inhoud),
|
||||
request.Bestandsnaam,
|
||||
request.Inhoud.Length,
|
||||
request.Vertrouwelijkheidaanduiding,
|
||||
request.Formaat,
|
||||
"definitief",
|
||||
// No usage-rights restrictions apply. Left null, OpenZaak rejects closing the related
|
||||
// zaak with "indicatiegebruiksrecht-unset"; false records the deliberate "none" answer.
|
||||
false),
|
||||
"Creating the informatieobject", ct);
|
||||
|
||||
// 2. Relate it to the zaak (Zaken API — no CRS).
|
||||
await PostAsync("/zaken/api/v1/zaakinformatieobjecten",
|
||||
new ZaakInformatieobjectDto(request.Zaak.ToString(), created.ToString()),
|
||||
"Relating the informatieobject to the zaak", ct);
|
||||
|
||||
return created;
|
||||
}
|
||||
|
||||
public async Task<Uri> ResolveZaaktypeUrlAsync(string identificatie, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(identificatie);
|
||||
|
||||
// The published zaaktype with this identificatie; status=definitief excludes concepts.
|
||||
var page = await GetAsync<ZaaktypePage>(
|
||||
"/catalogi/api/v1/zaaktypen?status=definitief&identificatie=" + Uri.EscapeDataString(identificatie),
|
||||
"zaaktypen", ct);
|
||||
var match = (page.Results ?? []).FirstOrDefault()
|
||||
?? throw new InvalidOperationException(
|
||||
$"No published zaaktype with identificatie '{identificatie}' found in OpenZaak — is the BIG catalogus seeded and published?");
|
||||
return new Uri(match.Url);
|
||||
}
|
||||
|
||||
public async Task<Uri> ResolveInformatieobjecttypeUrlAsync(string omschrijving, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(omschrijving);
|
||||
|
||||
// The informatieobjecttypen collection has no omschrijving filter, so match client-side over the
|
||||
// published ones.
|
||||
var page = await GetAsync<InformatieobjecttypePage>(
|
||||
"/catalogi/api/v1/informatieobjecttypen?status=definitief", "informatieobjecttypen", ct);
|
||||
var match = (page.Results ?? []).FirstOrDefault(i => i.Omschrijving == omschrijving)
|
||||
?? throw new InvalidOperationException(
|
||||
$"No published informatieobjecttype '{omschrijving}' found in OpenZaak — is the BIG catalogus seeded and published?");
|
||||
return new Uri(match.Url);
|
||||
}
|
||||
|
||||
// GETs an absolute-by-path ZGW resource with auth (no CRS — catalogi is not a geo API).
|
||||
private async Task<T> GetAsync<T>(string pathAndQuery, string label, CancellationToken ct)
|
||||
{
|
||||
using var message = new HttpRequestMessage(HttpMethod.Get, new Uri(options.BaseUrl, pathAndQuery));
|
||||
message.Headers.Authorization =
|
||||
new AuthenticationHeaderValue("Bearer", ZgwToken.Mint(options.ClientId, options.Secret));
|
||||
|
||||
using var response = await http.SendAsync(message, ct);
|
||||
await EnsureSuccessAsync(response, $"Querying {label}", ct);
|
||||
|
||||
return await response.Content.ReadFromJsonAsync<T>(ct)
|
||||
?? throw new InvalidOperationException($"OpenZaak returned an empty {label} response");
|
||||
}
|
||||
|
||||
// POSTs a non-geo ZGW resource (resultaat/status — no CRS headers). Buffers the body so uwsgi gets
|
||||
// a Content-Length instead of a chunked body (as with zaak-create).
|
||||
private async Task PostAsync(string path, object dto, string action, CancellationToken ct)
|
||||
@@ -200,26 +96,6 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
|
||||
await EnsureSuccessAsync(response, action, ct);
|
||||
}
|
||||
|
||||
// POSTs a non-geo ZGW resource and returns the created resource's URL (as PostAsync, but reads back
|
||||
// the `url` of the created object). Buffers the body so uwsgi gets a Content-Length.
|
||||
private async Task<Uri> PostForUrlAsync(string path, object dto, string action, CancellationToken ct)
|
||||
{
|
||||
using var message = new HttpRequestMessage(HttpMethod.Post, new Uri(options.BaseUrl, path))
|
||||
{
|
||||
Content = JsonContent.Create(dto),
|
||||
};
|
||||
message.Headers.Authorization =
|
||||
new AuthenticationHeaderValue("Bearer", ZgwToken.Mint(options.ClientId, options.Secret));
|
||||
await message.Content.LoadIntoBufferAsync(ct);
|
||||
|
||||
using var response = await http.SendAsync(message, ct);
|
||||
await EnsureSuccessAsync(response, action, ct);
|
||||
|
||||
var created = await response.Content.ReadFromJsonAsync<CreatedDto>(ct)
|
||||
?? throw new InvalidOperationException($"OpenZaak returned an empty response for {action}");
|
||||
return new Uri(created.Url);
|
||||
}
|
||||
|
||||
// EnsureSuccessStatusCode discards the response body; ZGW returns a JSON problem detail on 400 that
|
||||
// is essential for diagnosing a rejected request, so surface it in the exception.
|
||||
private static async Task EnsureSuccessAsync(HttpResponseMessage response, string action, CancellationToken ct)
|
||||
@@ -245,23 +121,13 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
|
||||
return new Uri(eindstatus.Url);
|
||||
}
|
||||
|
||||
/// <summary>Resolve a specific statustype from the catalogus by its omschrijving (e.g. "Geannuleerd").</summary>
|
||||
private async Task<Uri> ResolveStatustypeByOmschrijvingAsync(Uri zaaktypeUrl, string omschrijving, CancellationToken ct)
|
||||
{
|
||||
var page = await GetCatalogusAsync<StatustypePage>("statustypen", zaaktypeUrl, "statustypen", ct);
|
||||
var match = (page.Results ?? []).FirstOrDefault(s => s.Omschrijving == omschrijving)
|
||||
?? throw new InvalidOperationException($"No '{omschrijving}' statustype found for zaaktype {zaaktypeUrl}");
|
||||
return new Uri(match.Url);
|
||||
}
|
||||
|
||||
/// <summary>Resolve a specific resultaattype from the catalogus by its omschrijving (the seed defines
|
||||
/// "Geregistreerd" for approval and "Vervallen" for a document-timeout cancellation).</summary>
|
||||
private async Task<Uri> ResolveResultaattypeByOmschrijvingAsync(Uri zaaktypeUrl, string omschrijving, CancellationToken ct)
|
||||
/// <summary>Resolve the zaaktype's resultaattype from the catalogus (the seed defines one).</summary>
|
||||
private async Task<Uri> ResolveResultaattypeAsync(Uri zaaktypeUrl, CancellationToken ct)
|
||||
{
|
||||
var page = await GetCatalogusAsync<ResultaattypePage>("resultaattypen", zaaktypeUrl, "resultaattypen", ct);
|
||||
var match = (page.Results ?? []).FirstOrDefault(r => r.Omschrijving == omschrijving)
|
||||
?? throw new InvalidOperationException($"No '{omschrijving}' resultaattype found for zaaktype {zaaktypeUrl}");
|
||||
return new Uri(match.Url);
|
||||
var resultaattype = (page.Results ?? []).FirstOrDefault()
|
||||
?? throw new InvalidOperationException($"No resultaattypen found for zaaktype {zaaktypeUrl}");
|
||||
return new Uri(resultaattype.Url);
|
||||
}
|
||||
|
||||
// GETs a catalogus collection filtered by zaaktype (status=alles includes concept + published).
|
||||
@@ -305,8 +171,7 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
|
||||
private sealed record StatustypeDto(
|
||||
[property: JsonPropertyName("url")] string Url,
|
||||
[property: JsonPropertyName("volgnummer")] int Volgnummer,
|
||||
[property: JsonPropertyName("isEindstatus")] bool IsEindstatus,
|
||||
[property: JsonPropertyName("omschrijving")] string? Omschrijving);
|
||||
[property: JsonPropertyName("isEindstatus")] bool IsEindstatus);
|
||||
|
||||
private sealed record ResultaatDto(
|
||||
[property: JsonPropertyName("zaak")] string Zaak,
|
||||
@@ -316,42 +181,5 @@ public sealed class OpenZaakGateway(HttpClient http, OpenZaakOptions options) :
|
||||
[property: JsonPropertyName("results")] IReadOnlyList<ResultaattypeDto>? Results);
|
||||
|
||||
private sealed record ResultaattypeDto(
|
||||
[property: JsonPropertyName("url")] string Url,
|
||||
[property: JsonPropertyName("omschrijving")] string? Omschrijving);
|
||||
|
||||
private sealed record CreatedDto(
|
||||
[property: JsonPropertyName("url")] string Url);
|
||||
|
||||
private sealed record EnkelvoudigInformatieobjectDto(
|
||||
[property: JsonPropertyName("bronorganisatie")] string Bronorganisatie,
|
||||
[property: JsonPropertyName("creatiedatum")] string Creatiedatum,
|
||||
[property: JsonPropertyName("titel")] string Titel,
|
||||
[property: JsonPropertyName("auteur")] string Auteur,
|
||||
[property: JsonPropertyName("taal")] string Taal,
|
||||
[property: JsonPropertyName("informatieobjecttype")] string Informatieobjecttype,
|
||||
[property: JsonPropertyName("inhoud")] string Inhoud,
|
||||
[property: JsonPropertyName("bestandsnaam")] string Bestandsnaam,
|
||||
[property: JsonPropertyName("bestandsomvang")] int Bestandsomvang,
|
||||
[property: JsonPropertyName("vertrouwelijkheidaanduiding")] string Vertrouwelijkheidaanduiding,
|
||||
[property: JsonPropertyName("formaat")] string Formaat,
|
||||
[property: JsonPropertyName("status")] string Status,
|
||||
[property: JsonPropertyName("indicatieGebruiksrecht")] bool IndicatieGebruiksrecht);
|
||||
|
||||
private sealed record ZaakInformatieobjectDto(
|
||||
[property: JsonPropertyName("zaak")] string Zaak,
|
||||
[property: JsonPropertyName("informatieobject")] string Informatieobject);
|
||||
|
||||
private sealed record ZaaktypePage(
|
||||
[property: JsonPropertyName("results")] IReadOnlyList<ZaaktypeDto>? Results);
|
||||
|
||||
private sealed record ZaaktypeDto(
|
||||
[property: JsonPropertyName("url")] string Url,
|
||||
[property: JsonPropertyName("identificatie")] string? Identificatie);
|
||||
|
||||
private sealed record InformatieobjecttypePage(
|
||||
[property: JsonPropertyName("results")] IReadOnlyList<InformatieobjecttypeDto>? Results);
|
||||
|
||||
private sealed record InformatieobjecttypeDto(
|
||||
[property: JsonPropertyName("url")] string Url,
|
||||
[property: JsonPropertyName("omschrijving")] string? Omschrijving);
|
||||
}
|
||||
|
||||
@@ -77,18 +77,6 @@ public sealed class OpenZaakFixture : IDisposable
|
||||
return JsonDocument.Parse(json).RootElement.Clone();
|
||||
}
|
||||
|
||||
/// <summary>The URL of the published "Diploma" informatieobjecttype (S-10b), or null when the
|
||||
/// stack has not been seeded with OZ_PUBLISH=1. `status=definitief` returns published types only.</summary>
|
||||
public async Task<Uri?> FindPublishedDiplomaInformatieobjecttypeAsync(CancellationToken ct = default)
|
||||
{
|
||||
var query = new Uri(BaseUrl, "/catalogi/api/v1/informatieobjecttypen?status=definitief");
|
||||
var page = await GetJsonAsync(query, ct);
|
||||
foreach (var iot in page.GetProperty("results").EnumerateArray())
|
||||
if (iot.TryGetProperty("omschrijving", out var o) && o.GetString() == "Diploma")
|
||||
return new Uri(iot.GetProperty("url").GetString()!);
|
||||
return null;
|
||||
}
|
||||
|
||||
/// <summary>The zaaktype's eindstatus (terminal statustype) URL — the one an approval sets.</summary>
|
||||
public async Task<Uri> FindEindstatustypeAsync(Uri zaaktypeUrl, CancellationToken ct = default)
|
||||
{
|
||||
@@ -114,19 +102,6 @@ public sealed class OpenZaakFixture : IDisposable
|
||||
return fallback ?? throw new InvalidOperationException($"No statustypen for zaaktype {zaaktypeUrl}");
|
||||
}
|
||||
|
||||
/// <summary>Resolve a statustype by its omschrijving (e.g. the S-10c "Geannuleerd" cancellation status).</summary>
|
||||
public async Task<Uri> FindStatustypeByOmschrijvingAsync(Uri zaaktypeUrl, string omschrijving, CancellationToken ct = default)
|
||||
{
|
||||
var query = new Uri(BaseUrl,
|
||||
"/catalogi/api/v1/statustypen?status=alles&zaaktype=" + Uri.EscapeDataString(zaaktypeUrl.ToString()));
|
||||
var page = await GetJsonAsync(query, ct);
|
||||
foreach (var st in page.GetProperty("results").EnumerateArray())
|
||||
if (st.TryGetProperty("omschrijving", out var o) && o.GetString() == omschrijving)
|
||||
return new Uri(st.GetProperty("url").GetString()!);
|
||||
|
||||
throw new InvalidOperationException($"No '{omschrijving}' statustype for zaaktype {zaaktypeUrl}");
|
||||
}
|
||||
|
||||
// A ZGW (vng-api-common) HS256 JWT, mirroring the seed's client. Minted here
|
||||
// rather than reusing Acl.Infrastructure's internal minter to keep that internal.
|
||||
private string MintToken()
|
||||
|
||||
@@ -74,119 +74,4 @@ public sealed class OpenZaakGatewayIntegrationTests(OpenZaakFixture stack)
|
||||
var eindstatustype = await stack.FindEindstatustypeAsync(zaaktype!);
|
||||
Assert.Equal(eindstatustype.ToString(), status.GetProperty("statustype").GetString());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cancelling_a_zaak_records_the_geannuleerd_status_and_a_resultaat()
|
||||
{
|
||||
var zaaktype = await stack.FindPublishedBigZaaktypeAsync();
|
||||
Assert.True(zaaktype is not null,
|
||||
"No published BIG-REGISTRATIE zaaktype found in OpenZaak — bring the stack up and " +
|
||||
"seed it with OZ_PUBLISH=1 (`make integration` does this).");
|
||||
|
||||
var gateway = new OpenZaakGateway(stack.Http, stack.Options);
|
||||
var zaakUrl = await gateway.OpenZaakAsync(new ZaakRequest(
|
||||
Bronorganisatie: "517439943",
|
||||
VerantwoordelijkeOrganisatie: "517439943",
|
||||
Vertrouwelijkheidaanduiding: "openbaar",
|
||||
Zaaktype: zaaktype!,
|
||||
Startdatum: DateOnly.FromDateTime(DateTime.UtcNow),
|
||||
Identificatie: Guid.NewGuid().ToString()));
|
||||
|
||||
await gateway.SetZaakToCancellationStatusAsync(zaakUrl, zaaktype!, DateOnly.FromDateTime(DateTime.UtcNow));
|
||||
|
||||
// The zaak's current status is the Geannuleerd statustype — distinct from the approval eindstatus.
|
||||
var zaak = await stack.GetZaakAsync(zaakUrl);
|
||||
var statusUrl = zaak.GetProperty("status").GetString();
|
||||
Assert.False(string.IsNullOrEmpty(statusUrl), "the cancelled zaak has no current status");
|
||||
|
||||
var status = await stack.GetJsonAsync(new Uri(statusUrl!));
|
||||
var geannuleerd = await stack.FindStatustypeByOmschrijvingAsync(zaaktype!, "Geannuleerd");
|
||||
Assert.Equal(geannuleerd.ToString(), status.GetProperty("statustype").GetString());
|
||||
|
||||
// ...and a resultaat is recorded (OpenZaak requires it before a closing/terminal status).
|
||||
Assert.False(string.IsNullOrEmpty(zaak.GetProperty("resultaat").GetString()),
|
||||
"the cancelled zaak has no resultaat");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Storing_a_diploma_creates_a_real_informatieobject_related_to_the_zaak()
|
||||
{
|
||||
var zaaktype = await stack.FindPublishedBigZaaktypeAsync();
|
||||
Assert.True(zaaktype is not null,
|
||||
"No published BIG-REGISTRATIE zaaktype found — seed the stack with OZ_PUBLISH=1.");
|
||||
var informatieobjecttype = await stack.FindPublishedDiplomaInformatieobjecttypeAsync();
|
||||
Assert.True(informatieobjecttype is not null,
|
||||
"No published Diploma informatieobjecttype found — seed the stack with OZ_PUBLISH=1.");
|
||||
|
||||
var gateway = new OpenZaakGateway(stack.Http, stack.Options);
|
||||
var zaakUrl = await gateway.OpenZaakAsync(new ZaakRequest(
|
||||
Bronorganisatie: "517439943",
|
||||
VerantwoordelijkeOrganisatie: "517439943",
|
||||
Vertrouwelijkheidaanduiding: "openbaar",
|
||||
Zaaktype: zaaktype!,
|
||||
Startdatum: DateOnly.FromDateTime(DateTime.UtcNow),
|
||||
Identificatie: Guid.NewGuid().ToString()));
|
||||
|
||||
var content = System.Text.Encoding.UTF8.GetBytes("%PDF-1.4 synthetic diploma\n");
|
||||
var documentUrl = await gateway.StoreDocumentAsync(new DocumentRequest(
|
||||
Bronorganisatie: "517439943",
|
||||
Informatieobjecttype: informatieobjecttype!,
|
||||
Vertrouwelijkheidaanduiding: "openbaar",
|
||||
Zaak: zaakUrl,
|
||||
Creatiedatum: DateOnly.FromDateTime(DateTime.UtcNow),
|
||||
Titel: "Diploma",
|
||||
Auteur: "zorgprofessional",
|
||||
Taal: "nld",
|
||||
Bestandsnaam: "diploma.pdf",
|
||||
Formaat: "application/pdf",
|
||||
Inhoud: content));
|
||||
|
||||
// The gateway returns the canonical informatieobject URL...
|
||||
Assert.StartsWith(
|
||||
new Uri(stack.BaseUrl, "/documenten/api/v1/enkelvoudiginformatieobjecten/").ToString(),
|
||||
documentUrl.ToString());
|
||||
|
||||
// ...the document is really persisted with the default-filled fields...
|
||||
var doc = await stack.GetJsonAsync(documentUrl);
|
||||
Assert.Equal("diploma.pdf", doc.GetProperty("bestandsnaam").GetString());
|
||||
Assert.Equal(informatieobjecttype.ToString(), doc.GetProperty("informatieobjecttype").GetString());
|
||||
Assert.Equal(content.Length, doc.GetProperty("bestandsomvang").GetInt32());
|
||||
// indicatieGebruiksrecht is recorded as "no restrictions"; left null, OpenZaak would refuse to
|
||||
// close the zaak this document is related to (the S-10b regression that broke the e2e flow).
|
||||
Assert.False(doc.GetProperty("indicatieGebruiksrecht").GetBoolean());
|
||||
|
||||
// ...and it is related to the zaak (a zaakinformatieobject links the two).
|
||||
var relations = await stack.GetJsonAsync(new Uri(stack.BaseUrl,
|
||||
"/zaken/api/v1/zaakinformatieobjecten?informatieobject=" + Uri.EscapeDataString(documentUrl.ToString())));
|
||||
Assert.Contains(relations.EnumerateArray(),
|
||||
r => r.GetProperty("zaak").GetString() == zaakUrl.ToString());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolves_the_published_zaaktype_and_diploma_informatieobjecttype_by_business_key()
|
||||
{
|
||||
var expectedZaaktype = await stack.FindPublishedBigZaaktypeAsync();
|
||||
Assert.True(expectedZaaktype is not null,
|
||||
"No published BIG-REGISTRATIE zaaktype found — seed the stack with OZ_PUBLISH=1.");
|
||||
var expectedInformatieobjecttype = await stack.FindPublishedDiplomaInformatieobjecttypeAsync();
|
||||
Assert.True(expectedInformatieobjecttype is not null,
|
||||
"No published Diploma informatieobjecttype found — seed the stack with OZ_PUBLISH=1.");
|
||||
|
||||
var gateway = new OpenZaakGateway(stack.Http, stack.Options);
|
||||
|
||||
// The ACL discovers both URLs from the live Catalogi API by their stable business keys (S-27),
|
||||
// matching what the fixture found independently — no pinned URL needed.
|
||||
Assert.Equal(expectedZaaktype, await gateway.ResolveZaaktypeUrlAsync("BIG-REGISTRATIE"));
|
||||
Assert.Equal(expectedInformatieobjecttype, await gateway.ResolveInformatieobjecttypeUrlAsync("Diploma"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolving_an_unknown_zaaktype_identificatie_throws_a_clear_error()
|
||||
{
|
||||
var gateway = new OpenZaakGateway(stack.Http, stack.Options);
|
||||
|
||||
var ex = await Assert.ThrowsAsync<InvalidOperationException>(
|
||||
() => gateway.ResolveZaaktypeUrlAsync("NO-SUCH-ZAAKTYPE"));
|
||||
Assert.Contains("NO-SUCH-ZAAKTYPE", ex.Message);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -6,12 +6,6 @@ public class AclServiceTests
|
||||
{
|
||||
private sealed class FakeGateway : IZaakGateway
|
||||
{
|
||||
// The URLs the catalogus resolves the configured identificatie/omschrijving to (S-27).
|
||||
public Uri ResolvedZaaktype { get; } = new("http://openzaak/catalogi/api/v1/zaaktypen/big");
|
||||
public Uri ResolvedInformatieobjecttype { get; } = new("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip");
|
||||
public string? ResolvedByIdentificatie;
|
||||
public string? ResolvedByOmschrijving;
|
||||
|
||||
public ZaakRequest? Captured;
|
||||
public Uri Result { get; } = new("http://openzaak/zaken/api/v1/zaken/abc");
|
||||
|
||||
@@ -29,14 +23,6 @@ public class AclServiceTests
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public (Uri Zaak, Uri Zaaktype, DateOnly Datum)? Cancelled;
|
||||
|
||||
public Task SetZaakToCancellationStatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default)
|
||||
{
|
||||
Cancelled = (zaakUrl, zaaktypeUrl, datumStatusGezet);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Uri? ReadReferenceFor;
|
||||
|
||||
public Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default)
|
||||
@@ -44,27 +30,6 @@ public class AclServiceTests
|
||||
ReadReferenceFor = zaakUrl;
|
||||
return Task.FromResult("REG-FROM-ZAAK");
|
||||
}
|
||||
|
||||
public DocumentRequest? StoredDocument;
|
||||
public Uri DocumentResult { get; } = new("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc-1");
|
||||
|
||||
public Task<Uri> StoreDocumentAsync(DocumentRequest request, CancellationToken ct = default)
|
||||
{
|
||||
StoredDocument = request;
|
||||
return Task.FromResult(DocumentResult);
|
||||
}
|
||||
|
||||
public Task<Uri> ResolveZaaktypeUrlAsync(string identificatie, CancellationToken ct = default)
|
||||
{
|
||||
ResolvedByIdentificatie = identificatie;
|
||||
return Task.FromResult(ResolvedZaaktype);
|
||||
}
|
||||
|
||||
public Task<Uri> ResolveInformatieobjecttypeUrlAsync(string omschrijving, CancellationToken ct = default)
|
||||
{
|
||||
ResolvedByOmschrijving = omschrijving;
|
||||
return Task.FromResult(ResolvedInformatieobjecttype);
|
||||
}
|
||||
}
|
||||
|
||||
private static AclDefaults Defaults() => new()
|
||||
@@ -72,23 +37,26 @@ public class AclServiceTests
|
||||
Bronorganisatie = "517439943",
|
||||
VerantwoordelijkeOrganisatie = "517439943",
|
||||
Vertrouwelijkheidaanduiding = "openbaar",
|
||||
ZaaktypeIdentificatie = "BIG-REGISTRATIE",
|
||||
InformatieobjecttypeOmschrijving = "Diploma",
|
||||
ZaaktypeUrl = new("http://openzaak/catalogi/api/v1/zaaktypen/big"),
|
||||
};
|
||||
|
||||
private static AclService ServiceWith(FakeGateway gateway, AclDefaults defaults, DateOnly today) =>
|
||||
new(gateway, defaults, new CachedZaaktypeCatalog(gateway, defaults), new FixedClock(today));
|
||||
|
||||
private sealed class FixedClock(DateOnly today) : IClock
|
||||
{
|
||||
public DateOnly Today { get; } = today;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Opening_a_zaak_default_fills_zgw_fields_and_uses_the_resolved_zaaktype()
|
||||
public async Task Opening_a_zaak_default_fills_zgw_fields_and_returns_the_zaak_url()
|
||||
{
|
||||
var gateway = new FakeGateway();
|
||||
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
||||
var defaults = new AclDefaults
|
||||
{
|
||||
Bronorganisatie = "517439943",
|
||||
VerantwoordelijkeOrganisatie = "517439943",
|
||||
Vertrouwelijkheidaanduiding = "openbaar",
|
||||
ZaaktypeUrl = new("http://openzaak/catalogi/api/v1/zaaktypen/big"),
|
||||
};
|
||||
var service = new AclService(gateway, defaults, new FixedClock(new DateOnly(2026, 6, 4)));
|
||||
|
||||
var url = await service.OpenZaakAsync(new DomainRegistration("123456782", "reg-77"));
|
||||
|
||||
@@ -97,9 +65,7 @@ public class AclServiceTests
|
||||
Assert.Equal("517439943", req.Bronorganisatie);
|
||||
Assert.Equal("517439943", req.VerantwoordelijkeOrganisatie);
|
||||
Assert.Equal("openbaar", req.Vertrouwelijkheidaanduiding);
|
||||
// The zaaktype is resolved from the configured identificatie, not a pinned URL (S-27).
|
||||
Assert.Equal("BIG-REGISTRATIE", gateway.ResolvedByIdentificatie);
|
||||
Assert.Equal(gateway.ResolvedZaaktype, req.Zaaktype);
|
||||
Assert.Equal(defaults.ZaaktypeUrl, req.Zaaktype);
|
||||
Assert.Equal(new DateOnly(2026, 6, 4), req.Startdatum);
|
||||
// The registration reference becomes the zaak identificatie (#78).
|
||||
Assert.Equal("reg-77", req.Identificatie);
|
||||
@@ -109,24 +75,32 @@ public class AclServiceTests
|
||||
public async Task Rejects_a_null_registration_without_calling_the_gateway()
|
||||
{
|
||||
var gateway = new FakeGateway();
|
||||
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
||||
var defaults = new AclDefaults
|
||||
{
|
||||
Bronorganisatie = "517439943",
|
||||
VerantwoordelijkeOrganisatie = "517439943",
|
||||
Vertrouwelijkheidaanduiding = "openbaar",
|
||||
ZaaktypeUrl = new("http://openzaak/catalogi/api/v1/zaaktypen/big"),
|
||||
};
|
||||
var service = new AclService(gateway, defaults, new FixedClock(new DateOnly(2026, 6, 4)));
|
||||
|
||||
await Assert.ThrowsAsync<ArgumentNullException>(() => service.OpenZaakAsync(null!));
|
||||
Assert.Null(gateway.Captured);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Approving_a_zaak_sets_it_to_its_resolved_zaaktypes_eindstatus_dated_today()
|
||||
public async Task Approving_a_zaak_sets_it_to_its_zaaktypes_eindstatus_dated_today()
|
||||
{
|
||||
var gateway = new FakeGateway();
|
||||
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
||||
var defaults = Defaults();
|
||||
var service = new AclService(gateway, defaults, new FixedClock(new DateOnly(2026, 6, 4)));
|
||||
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
|
||||
|
||||
await service.ApproveZaakAsync(zaak);
|
||||
|
||||
Assert.NotNull(gateway.Approved);
|
||||
Assert.Equal(zaak, gateway.Approved!.Value.Zaak);
|
||||
Assert.Equal(gateway.ResolvedZaaktype, gateway.Approved.Value.Zaaktype);
|
||||
Assert.Equal(defaults.ZaaktypeUrl, gateway.Approved.Value.Zaaktype);
|
||||
Assert.Equal(new DateOnly(2026, 6, 4), gateway.Approved.Value.Datum);
|
||||
}
|
||||
|
||||
@@ -134,80 +108,17 @@ public class AclServiceTests
|
||||
public async Task Approving_a_null_zaak_is_rejected_without_touching_the_gateway()
|
||||
{
|
||||
var gateway = new FakeGateway();
|
||||
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
||||
var service = new AclService(gateway, Defaults(), new FixedClock(new DateOnly(2026, 6, 4)));
|
||||
|
||||
await Assert.ThrowsAsync<ArgumentNullException>(() => service.ApproveZaakAsync(null!));
|
||||
Assert.Null(gateway.Approved);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cancelling_a_zaak_sets_it_to_the_cancellation_status_dated_today()
|
||||
{
|
||||
var gateway = new FakeGateway();
|
||||
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
||||
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
|
||||
|
||||
await service.CancelZaakAsync(zaak);
|
||||
|
||||
Assert.NotNull(gateway.Cancelled);
|
||||
Assert.Equal(zaak, gateway.Cancelled!.Value.Zaak);
|
||||
Assert.Equal(gateway.ResolvedZaaktype, gateway.Cancelled.Value.Zaaktype);
|
||||
Assert.Equal(new DateOnly(2026, 6, 4), gateway.Cancelled.Value.Datum);
|
||||
// Cancellation must not touch the approval path.
|
||||
Assert.Null(gateway.Approved);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cancelling_a_null_zaak_is_rejected_without_touching_the_gateway()
|
||||
{
|
||||
var gateway = new FakeGateway();
|
||||
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
||||
|
||||
await Assert.ThrowsAsync<ArgumentNullException>(() => service.CancelZaakAsync(null!));
|
||||
Assert.Null(gateway.Cancelled);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Storing_a_diploma_default_fills_the_document_fields_and_uses_the_resolved_informatieobjecttype()
|
||||
{
|
||||
var gateway = new FakeGateway();
|
||||
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
||||
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
|
||||
|
||||
var url = await service.StoreDiplomaAsync(zaak, [1, 2, 3], "diploma.pdf", "application/pdf");
|
||||
|
||||
Assert.Equal(gateway.DocumentResult, url);
|
||||
var req = gateway.StoredDocument!;
|
||||
Assert.Equal(zaak, req.Zaak);
|
||||
// The informatieobjecttype is resolved from the configured omschrijving (S-27).
|
||||
Assert.Equal("Diploma", gateway.ResolvedByOmschrijving);
|
||||
Assert.Equal(gateway.ResolvedInformatieobjecttype, req.Informatieobjecttype);
|
||||
Assert.Equal("517439943", req.Bronorganisatie);
|
||||
Assert.Equal("openbaar", req.Vertrouwelijkheidaanduiding);
|
||||
Assert.Equal(new DateOnly(2026, 6, 4), req.Creatiedatum);
|
||||
Assert.Equal("nld", req.Taal);
|
||||
Assert.Equal("diploma.pdf", req.Bestandsnaam);
|
||||
Assert.Equal("application/pdf", req.Formaat);
|
||||
Assert.Equal(new byte[] { 1, 2, 3 }, req.Inhoud);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Storing_a_diploma_rejects_null_or_blank_arguments()
|
||||
{
|
||||
var service = ServiceWith(new FakeGateway(), Defaults(), new DateOnly(2026, 6, 4));
|
||||
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
|
||||
|
||||
await Assert.ThrowsAsync<ArgumentNullException>(() => service.StoreDiplomaAsync(null!, [1], "d.pdf", "application/pdf"));
|
||||
await Assert.ThrowsAsync<ArgumentNullException>(() => service.StoreDiplomaAsync(zaak, null!, "d.pdf", "application/pdf"));
|
||||
await Assert.ThrowsAnyAsync<ArgumentException>(() => service.StoreDiplomaAsync(zaak, [1], " ", "application/pdf"));
|
||||
await Assert.ThrowsAnyAsync<ArgumentException>(() => service.StoreDiplomaAsync(zaak, [1], "d.pdf", " "));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Reading_a_zaak_reference_returns_the_zaaks_identificatie()
|
||||
{
|
||||
var gateway = new FakeGateway();
|
||||
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
||||
var service = new AclService(gateway, Defaults(), new FixedClock(new DateOnly(2026, 6, 4)));
|
||||
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/abc");
|
||||
|
||||
var reference = await service.GetZaakReferenceAsync(zaak);
|
||||
@@ -220,7 +131,7 @@ public class AclServiceTests
|
||||
public async Task Reading_a_null_zaak_reference_is_rejected()
|
||||
{
|
||||
var gateway = new FakeGateway();
|
||||
var service = ServiceWith(gateway, Defaults(), new DateOnly(2026, 6, 4));
|
||||
var service = new AclService(gateway, Defaults(), new FixedClock(new DateOnly(2026, 6, 4)));
|
||||
|
||||
await Assert.ThrowsAsync<ArgumentNullException>(() => service.GetZaakReferenceAsync(null!));
|
||||
Assert.Null(gateway.ReadReferenceFor);
|
||||
|
||||
@@ -173,8 +173,7 @@ public class OpenZaakGatewayTests
|
||||
private sealed class OzRoutes
|
||||
{
|
||||
public string StatustypenJson { get; init; } = StatustypenPage(withEindstatusFlag: true);
|
||||
public string ResultaattypenJson { get; init; } =
|
||||
"""{"results":[{"url":"http://openzaak/catalogi/api/v1/resultaattypen/1","omschrijving":"Geregistreerd"}]}""";
|
||||
public string ResultaattypenJson { get; init; } = """{"results":[{"url":"http://openzaak/catalogi/api/v1/resultaattypen/1"}]}""";
|
||||
public HttpStatusCode StatustypenStatus { get; init; } = HttpStatusCode.OK;
|
||||
public HttpStatusCode ResultaattypenStatus { get; init; } = HttpStatusCode.OK;
|
||||
public HttpStatusCode ResultaatPostStatus { get; init; } = HttpStatusCode.Created;
|
||||
@@ -252,138 +251,6 @@ public class OpenZaakGatewayTests
|
||||
Assert.True(status.Length > 0);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Approving_selects_the_geregistreerd_resultaat_by_name_when_several_exist()
|
||||
{
|
||||
// Once S-10c adds a second resultaattype (Vervallen), picking the first is ambiguous — the
|
||||
// Zaken API does not guarantee order. Approval must resolve its resultaat by omschrijving.
|
||||
var rec = new Recorder();
|
||||
var twoResultaattypen = """
|
||||
{"results":[
|
||||
{"url":"http://openzaak/catalogi/api/v1/resultaattypen/vervallen","omschrijving":"Vervallen"},
|
||||
{"url":"http://openzaak/catalogi/api/v1/resultaattypen/geregistreerd","omschrijving":"Geregistreerd"}
|
||||
]}
|
||||
""";
|
||||
|
||||
await Gateway(ApprovalStub(rec, new OzRoutes { ResultaattypenJson = twoResultaattypen }))
|
||||
.SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4));
|
||||
|
||||
Assert.Contains("\"resultaattype\":\"http://openzaak/catalogi/api/v1/resultaattypen/geregistreerd\"",
|
||||
rec.Sent("/resultaten").Body);
|
||||
}
|
||||
|
||||
// --- SetZaakToCancellationStatusAsync (document-timeout cancellation / S-10c) ---
|
||||
|
||||
// A catalogus with the three statustypen S-10c seeds (Geannuleerd is non-terminal, below the
|
||||
// Afgehandeld eindstatus) and both resultaattypen. Cancellation must resolve "Geannuleerd" and
|
||||
// "Vervallen" by omschrijving, never the approval pair.
|
||||
private const string CancellationStatustypenJson = """
|
||||
{"results":[
|
||||
{"url":"http://openzaak/catalogi/api/v1/statustypen/ontvangen","volgnummer":1,"omschrijving":"Ontvangen","isEindstatus":false},
|
||||
{"url":"http://openzaak/catalogi/api/v1/statustypen/geannuleerd","volgnummer":2,"omschrijving":"Geannuleerd","isEindstatus":false},
|
||||
{"url":"http://openzaak/catalogi/api/v1/statustypen/afgehandeld","volgnummer":3,"omschrijving":"Afgehandeld","isEindstatus":true}
|
||||
]}
|
||||
""";
|
||||
|
||||
private const string CancellationResultaattypenJson = """
|
||||
{"results":[
|
||||
{"url":"http://openzaak/catalogi/api/v1/resultaattypen/geregistreerd","omschrijving":"Geregistreerd"},
|
||||
{"url":"http://openzaak/catalogi/api/v1/resultaattypen/vervallen","omschrijving":"Vervallen"}
|
||||
]}
|
||||
""";
|
||||
|
||||
[Fact]
|
||||
public async Task Cancelling_records_the_vervallen_resultaat_then_the_geannuleerd_status_against_the_zaak()
|
||||
{
|
||||
var rec = new Recorder();
|
||||
|
||||
await Gateway(ApprovalStub(rec, new OzRoutes
|
||||
{
|
||||
StatustypenJson = CancellationStatustypenJson,
|
||||
ResultaattypenJson = CancellationResultaattypenJson,
|
||||
})).SetZaakToCancellationStatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4));
|
||||
|
||||
// Resultaat precedes status (OpenZaak requires a resultaat before a closing/terminal status).
|
||||
Assert.True(rec.IndexOf("/resultaten") < rec.IndexOf("/statussen"));
|
||||
|
||||
var resultaat = rec.Sent("/resultaten");
|
||||
Assert.Contains("\"zaak\":\"" + ZaakUrl + "\"", resultaat.Body);
|
||||
// The cancellation resultaat (Vervallen) is chosen by name — not the approval one (Geregistreerd).
|
||||
Assert.Contains("\"resultaattype\":\"http://openzaak/catalogi/api/v1/resultaattypen/vervallen\"", resultaat.Body);
|
||||
|
||||
var status = rec.Sent("/statussen");
|
||||
Assert.Contains("\"zaak\":\"" + ZaakUrl + "\"", status.Body);
|
||||
// The Geannuleerd statustype is chosen by name — not the Afgehandeld eindstatus (approval).
|
||||
Assert.Contains("\"statustype\":\"http://openzaak/catalogi/api/v1/statustypen/geannuleerd\"", status.Body);
|
||||
Assert.Contains("\"datumStatusGezet\":\"2026-06-04T00:00:00Z\"", status.Body);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cancelling_throws_when_the_zaaktype_has_no_geannuleerd_statustype()
|
||||
{
|
||||
var rec = new Recorder();
|
||||
|
||||
var ex = await Assert.ThrowsAsync<InvalidOperationException>(() =>
|
||||
Gateway(ApprovalStub(rec, new OzRoutes
|
||||
{
|
||||
// Only the approval statustypen — no "Geannuleerd".
|
||||
StatustypenJson = StatustypenPage(withEindstatusFlag: true),
|
||||
ResultaattypenJson = CancellationResultaattypenJson,
|
||||
})).SetZaakToCancellationStatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
|
||||
|
||||
Assert.Contains("Geannuleerd", ex.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cancelling_rejects_a_null_zaak_without_calling_openzaak()
|
||||
{
|
||||
var handler = new StubHandler(_ => throw new InvalidOperationException("should not be sent"));
|
||||
await Assert.ThrowsAsync<ArgumentNullException>(() =>
|
||||
Gateway(handler).SetZaakToCancellationStatusAsync(null!, Zaaktype, new DateOnly(2026, 6, 4)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cancelling_rejects_a_null_zaaktype_without_calling_openzaak()
|
||||
{
|
||||
var handler = new StubHandler(_ => throw new InvalidOperationException("should not be sent"));
|
||||
await Assert.ThrowsAsync<ArgumentNullException>(() =>
|
||||
Gateway(handler).SetZaakToCancellationStatusAsync(new Uri(ZaakUrl), null!, new DateOnly(2026, 6, 4)));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cancelling_surfaces_the_failure_when_recording_the_resultaat_is_rejected()
|
||||
{
|
||||
var rec = new Recorder();
|
||||
|
||||
var ex = await Assert.ThrowsAsync<HttpRequestException>(() =>
|
||||
Gateway(ApprovalStub(rec, new OzRoutes
|
||||
{
|
||||
StatustypenJson = CancellationStatustypenJson,
|
||||
ResultaattypenJson = CancellationResultaattypenJson,
|
||||
ResultaatPostStatus = HttpStatusCode.BadRequest,
|
||||
})).SetZaakToCancellationStatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
|
||||
|
||||
Assert.Contains("cancellation resultaat", ex.Message);
|
||||
// It fails on the resultaat, before it ever posts the status.
|
||||
Assert.Equal(-1, rec.IndexOf("/statussen"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cancelling_surfaces_the_failure_when_recording_the_status_is_rejected()
|
||||
{
|
||||
var rec = new Recorder();
|
||||
|
||||
var ex = await Assert.ThrowsAsync<HttpRequestException>(() =>
|
||||
Gateway(ApprovalStub(rec, new OzRoutes
|
||||
{
|
||||
StatustypenJson = CancellationStatustypenJson,
|
||||
ResultaattypenJson = CancellationResultaattypenJson,
|
||||
StatusPostStatus = HttpStatusCode.BadRequest,
|
||||
})).SetZaakToCancellationStatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
|
||||
|
||||
Assert.Contains("cancellation status", ex.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Approving_falls_back_to_the_highest_volgnummer_when_no_eindstatus_is_flagged()
|
||||
{
|
||||
@@ -458,7 +325,7 @@ public class OpenZaakGatewayTests
|
||||
Gateway(ApprovalStub(rec, new OzRoutes { ResultaattypenJson = "{}" }))
|
||||
.SetZaakToEindstatusAsync(new Uri(ZaakUrl), Zaaktype, new DateOnly(2026, 6, 4)));
|
||||
|
||||
Assert.Contains("'Geregistreerd' resultaattype", ex.Message);
|
||||
Assert.Contains("No resultaattypen found", ex.Message);
|
||||
// Resolved the eindstatus + queried resultaattypen, but posted nothing.
|
||||
Assert.Equal(-1, rec.IndexOf("/resultaten"));
|
||||
Assert.Equal(-1, rec.IndexOf("/statussen"));
|
||||
@@ -565,263 +432,4 @@ public class OpenZaakGatewayTests
|
||||
b64 = (b64.Length % 4) switch { 2 => b64 + "==", 3 => b64 + "=", _ => b64 };
|
||||
return Encoding.UTF8.GetString(Convert.FromBase64String(b64));
|
||||
}
|
||||
|
||||
// --- StoreDocumentAsync (diploma upload / S-10b) ---
|
||||
|
||||
private static readonly Uri Informatieobjecttype =
|
||||
new("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip");
|
||||
|
||||
private static DocumentRequest SampleDocument(byte[]? inhoud = null) => new(
|
||||
Bronorganisatie: "517439943",
|
||||
Informatieobjecttype: Informatieobjecttype,
|
||||
Vertrouwelijkheidaanduiding: "openbaar",
|
||||
Zaak: new Uri(ZaakUrl),
|
||||
Creatiedatum: new DateOnly(2026, 6, 4),
|
||||
Titel: "Diploma",
|
||||
Auteur: "zorgprofessional",
|
||||
Taal: "nld",
|
||||
Bestandsnaam: "diploma.pdf",
|
||||
Formaat: "application/pdf",
|
||||
Inhoud: inhoud ?? [1, 2, 3, 4]);
|
||||
|
||||
// Routes the two document calls: POST /enkelvoudiginformatieobjecten (documenten) then
|
||||
// POST /zaakinformatieobjecten (zaken).
|
||||
private static StubHandler DocumentStub(Recorder rec) => new(async req =>
|
||||
{
|
||||
rec.Requests.Add(req);
|
||||
rec.ContentLengths.Add(req.Content?.Headers.ContentLength);
|
||||
rec.Bodies.Add(req.Content is null ? null : await req.Content.ReadAsStringAsync());
|
||||
|
||||
return req.RequestUri!.ToString().Contains("/enkelvoudiginformatieobjecten")
|
||||
? Json(HttpStatusCode.Created, """{"url":"http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc-1"}""")
|
||||
: Json(HttpStatusCode.Created, """{"url":"http://openzaak/zaken/api/v1/zaakinformatieobjecten/rel-1"}""");
|
||||
});
|
||||
|
||||
[Fact]
|
||||
public async Task Storing_a_document_creates_the_informatieobject_then_relates_it_to_the_zaak()
|
||||
{
|
||||
var rec = new Recorder();
|
||||
|
||||
var url = await Gateway(DocumentStub(rec)).StoreDocumentAsync(SampleDocument([10, 20, 30]));
|
||||
|
||||
Assert.Equal("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc-1", url.ToString());
|
||||
|
||||
// 1. Create the enkelvoudiginformatieobject in the Documenten API.
|
||||
var create = rec.Sent("/enkelvoudiginformatieobjecten");
|
||||
Assert.Equal(HttpMethod.Post, create.Request.Method);
|
||||
Assert.Equal("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten",
|
||||
create.Request.RequestUri!.ToString());
|
||||
Assert.Equal("Bearer", create.Request.Headers.Authorization!.Scheme);
|
||||
Assert.Contains("\"bronorganisatie\":\"517439943\"", create.Body);
|
||||
Assert.Contains("\"informatieobjecttype\":\"http://openzaak/catalogi/api/v1/informatieobjecttypen/dip\"", create.Body);
|
||||
Assert.Contains("\"creatiedatum\":\"2026-06-04\"", create.Body);
|
||||
Assert.Contains("\"titel\":\"Diploma\"", create.Body);
|
||||
Assert.Contains("\"auteur\":\"zorgprofessional\"", create.Body);
|
||||
Assert.Contains("\"taal\":\"nld\"", create.Body);
|
||||
Assert.Contains("\"bestandsnaam\":\"diploma.pdf\"", create.Body);
|
||||
Assert.Contains("\"formaat\":\"application/pdf\"", create.Body);
|
||||
Assert.Contains("\"vertrouwelijkheidaanduiding\":\"openbaar\"", create.Body);
|
||||
Assert.Contains("\"status\":\"definitief\"", create.Body);
|
||||
// indicatieGebruiksrecht must be set explicitly (false = no usage restrictions); left null,
|
||||
// OpenZaak refuses to close the zaak this document is related to ("indicatiegebruiksrecht-unset").
|
||||
Assert.Contains("\"indicatieGebruiksrecht\":false", create.Body);
|
||||
// The file content is base64-encoded into `inhoud`, with its byte length in `bestandsomvang`.
|
||||
Assert.Contains($"\"inhoud\":\"{Convert.ToBase64String([10, 20, 30])}\"", create.Body);
|
||||
Assert.Contains("\"bestandsomvang\":3", create.Body);
|
||||
|
||||
// 2. Relate that informatieobject to the zaak (Zaken API — no CRS).
|
||||
var relate = rec.Sent("/zaakinformatieobjecten");
|
||||
Assert.Equal(HttpMethod.Post, relate.Request.Method);
|
||||
Assert.Equal("http://openzaak/zaken/api/v1/zaakinformatieobjecten",
|
||||
relate.Request.RequestUri!.ToString());
|
||||
Assert.Contains($"\"zaak\":\"{ZaakUrl}\"", relate.Body);
|
||||
Assert.Contains("\"informatieobject\":\"http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc-1\"", relate.Body);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Storing_a_document_buffers_the_body_and_sends_no_crs_headers()
|
||||
{
|
||||
// uwsgi rejects a chunked body (Content-Length must be present); the Documenten API is not a
|
||||
// geo API, so no CRS headers (unlike the Zaken zaak-create).
|
||||
var rec = new Recorder();
|
||||
|
||||
await Gateway(DocumentStub(rec)).StoreDocumentAsync(SampleDocument());
|
||||
|
||||
var create = rec.Sent("/enkelvoudiginformatieobjecten");
|
||||
Assert.NotNull(create.Length);
|
||||
Assert.True(create.Length > 0);
|
||||
Assert.False(create.Request.Headers.Contains("Accept-Crs"));
|
||||
Assert.False(create.Request.Content!.Headers.Contains("Content-Crs"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Storing_a_document_surfaces_an_openzaak_rejection()
|
||||
{
|
||||
var handler = new StubHandler(_ =>
|
||||
Task.FromResult(new HttpResponseMessage(HttpStatusCode.BadRequest)
|
||||
{
|
||||
Content = new StringContent("""{"detail":"bad"}""", Encoding.UTF8, "application/json"),
|
||||
}));
|
||||
|
||||
var ex = await Assert.ThrowsAsync<HttpRequestException>(
|
||||
() => Gateway(handler).StoreDocumentAsync(SampleDocument()));
|
||||
Assert.Contains("bad", ex.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Storing_a_document_rejects_a_null_request()
|
||||
{
|
||||
var handler = new StubHandler(_ => throw new InvalidOperationException("should not be sent"));
|
||||
|
||||
await Assert.ThrowsAsync<ArgumentNullException>(() => Gateway(handler).StoreDocumentAsync(null!));
|
||||
}
|
||||
|
||||
// ── Catalogi resolution by business key (S-27) ────────────────────────────────────────────────
|
||||
|
||||
[Fact]
|
||||
public async Task Resolves_the_published_zaaktype_url_by_identificatie()
|
||||
{
|
||||
HttpRequestMessage? seen = null;
|
||||
var handler = new StubHandler(req =>
|
||||
{
|
||||
seen = req;
|
||||
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = JsonContent.Create(new
|
||||
{
|
||||
results = new[] { new { url = "http://openzaak/catalogi/api/v1/zaaktypen/big", identificatie = "BIG-REGISTRATIE" } },
|
||||
}),
|
||||
});
|
||||
});
|
||||
|
||||
var url = await Gateway(handler).ResolveZaaktypeUrlAsync("BIG-REGISTRATIE");
|
||||
|
||||
Assert.Equal("http://openzaak/catalogi/api/v1/zaaktypen/big", url.ToString());
|
||||
Assert.Equal(HttpMethod.Get, seen!.Method);
|
||||
// Filters to the published zaaktype with that identificatie, and authenticates.
|
||||
Assert.Contains("/catalogi/api/v1/zaaktypen", seen.RequestUri!.ToString());
|
||||
Assert.Contains("status=definitief", seen.RequestUri!.Query);
|
||||
Assert.Contains("identificatie=BIG-REGISTRATIE", seen.RequestUri!.Query);
|
||||
Assert.Equal("Bearer", seen.Headers.Authorization!.Scheme);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolving_a_zaaktype_throws_a_clear_error_when_none_is_published()
|
||||
{
|
||||
var handler = new StubHandler(_ => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = JsonContent.Create(new { results = Array.Empty<object>() }),
|
||||
}));
|
||||
|
||||
var ex = await Assert.ThrowsAsync<InvalidOperationException>(
|
||||
() => Gateway(handler).ResolveZaaktypeUrlAsync("BIG-REGISTRATIE"));
|
||||
Assert.Contains("BIG-REGISTRATIE", ex.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolves_the_informatieobjecttype_url_by_omschrijving()
|
||||
{
|
||||
HttpRequestMessage? seen = null;
|
||||
var handler = new StubHandler(req =>
|
||||
{
|
||||
seen = req;
|
||||
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = JsonContent.Create(new
|
||||
{
|
||||
results = new[]
|
||||
{
|
||||
new { url = "http://openzaak/catalogi/api/v1/informatieobjecttypen/other", omschrijving = "Overig" },
|
||||
new { url = "http://openzaak/catalogi/api/v1/informatieobjecttypen/dip", omschrijving = "Diploma" },
|
||||
},
|
||||
}),
|
||||
});
|
||||
});
|
||||
|
||||
var url = await Gateway(handler).ResolveInformatieobjecttypeUrlAsync("Diploma");
|
||||
|
||||
// Queries the published informatieobjecttypen collection, and matches on omschrijving (not position).
|
||||
Assert.Contains("/catalogi/api/v1/informatieobjecttypen", seen!.RequestUri!.ToString());
|
||||
Assert.Contains("status=definitief", seen.RequestUri!.Query);
|
||||
Assert.Equal("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip", url.ToString());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolving_a_zaaktype_throws_when_the_response_carries_no_results()
|
||||
{
|
||||
// No "results" property → the page's Results is null; the gateway must treat that as "none
|
||||
// found" (not dereference null).
|
||||
var handler = new StubHandler(_ => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = JsonContent.Create(new { count = 0 }),
|
||||
}));
|
||||
|
||||
await Assert.ThrowsAsync<InvalidOperationException>(
|
||||
() => Gateway(handler).ResolveZaaktypeUrlAsync("BIG-REGISTRATIE"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolving_an_informatieobjecttype_throws_when_the_response_carries_no_results()
|
||||
{
|
||||
var handler = new StubHandler(_ => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = JsonContent.Create(new { count = 0 }),
|
||||
}));
|
||||
|
||||
await Assert.ThrowsAsync<InvalidOperationException>(
|
||||
() => Gateway(handler).ResolveInformatieobjecttypeUrlAsync("Diploma"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolving_a_zaaktype_surfaces_a_non_success_catalogi_response()
|
||||
{
|
||||
var handler = new StubHandler(_ => Task.FromResult(new HttpResponseMessage(HttpStatusCode.InternalServerError)
|
||||
{
|
||||
Content = new StringContent("boom"),
|
||||
}));
|
||||
|
||||
var ex = await Assert.ThrowsAsync<HttpRequestException>(
|
||||
() => Gateway(handler).ResolveZaaktypeUrlAsync("BIG-REGISTRATIE"));
|
||||
// The error names the resource being queried and includes OpenZaak's body.
|
||||
Assert.Contains("zaaktypen", ex.Message);
|
||||
Assert.Contains("boom", ex.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolving_an_informatieobjecttype_surfaces_a_non_success_catalogi_response()
|
||||
{
|
||||
var handler = new StubHandler(_ => Task.FromResult(new HttpResponseMessage(HttpStatusCode.InternalServerError)
|
||||
{
|
||||
Content = new StringContent("boom"),
|
||||
}));
|
||||
|
||||
var ex = await Assert.ThrowsAsync<HttpRequestException>(
|
||||
() => Gateway(handler).ResolveInformatieobjecttypeUrlAsync("Diploma"));
|
||||
Assert.Contains("informatieobjecttypen", ex.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolving_an_informatieobjecttype_throws_when_no_omschrijving_matches()
|
||||
{
|
||||
var handler = new StubHandler(_ => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = JsonContent.Create(new
|
||||
{
|
||||
results = new[] { new { url = "http://openzaak/catalogi/api/v1/informatieobjecttypen/other", omschrijving = "Overig" } },
|
||||
}),
|
||||
}));
|
||||
|
||||
var ex = await Assert.ThrowsAsync<InvalidOperationException>(
|
||||
() => Gateway(handler).ResolveInformatieobjecttypeUrlAsync("Diploma"));
|
||||
Assert.Contains("Diploma", ex.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Resolving_rejects_a_blank_business_key_without_calling_openzaak()
|
||||
{
|
||||
var handler = new StubHandler(_ => throw new InvalidOperationException("should not be sent"));
|
||||
|
||||
await Assert.ThrowsAnyAsync<ArgumentException>(() => Gateway(handler).ResolveZaaktypeUrlAsync(" "));
|
||||
await Assert.ThrowsAnyAsync<ArgumentException>(() => Gateway(handler).ResolveInformatieobjecttypeUrlAsync(" "));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,92 +0,0 @@
|
||||
using Acl.Application;
|
||||
|
||||
namespace Acl.Tests;
|
||||
|
||||
public class ZaaktypeCatalogTests
|
||||
{
|
||||
// A gateway that only supports resolution; the other members are unused here.
|
||||
private sealed class ResolvingGateway : IZaakGateway
|
||||
{
|
||||
public int ZaaktypeCalls;
|
||||
public int InformatieobjecttypeCalls;
|
||||
public string? LastIdentificatie;
|
||||
public string? LastOmschrijving;
|
||||
public int ThrowZaaktypeTimes;
|
||||
public Uri ZaaktypeUrl { get; } = new("http://openzaak/catalogi/api/v1/zaaktypen/big");
|
||||
public Uri InformatieobjecttypeUrl { get; } = new("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip");
|
||||
|
||||
public Task<Uri> ResolveZaaktypeUrlAsync(string identificatie, CancellationToken ct = default)
|
||||
{
|
||||
ZaaktypeCalls++;
|
||||
LastIdentificatie = identificatie;
|
||||
if (ZaaktypeCalls <= ThrowZaaktypeTimes)
|
||||
throw new InvalidOperationException("no published zaaktype yet");
|
||||
return Task.FromResult(ZaaktypeUrl);
|
||||
}
|
||||
|
||||
public Task<Uri> ResolveInformatieobjecttypeUrlAsync(string omschrijving, CancellationToken ct = default)
|
||||
{
|
||||
InformatieobjecttypeCalls++;
|
||||
LastOmschrijving = omschrijving;
|
||||
return Task.FromResult(InformatieobjecttypeUrl);
|
||||
}
|
||||
|
||||
public Task<Uri> OpenZaakAsync(ZaakRequest request, CancellationToken ct = default) => throw new NotSupportedException();
|
||||
public Task SetZaakToEindstatusAsync(Uri z, Uri zt, DateOnly d, CancellationToken ct = default) => throw new NotSupportedException();
|
||||
public Task SetZaakToCancellationStatusAsync(Uri z, Uri zt, DateOnly d, CancellationToken ct = default) => throw new NotSupportedException();
|
||||
public Task<string> GetZaakIdentificatieAsync(Uri z, CancellationToken ct = default) => throw new NotSupportedException();
|
||||
public Task<Uri> StoreDocumentAsync(DocumentRequest r, CancellationToken ct = default) => throw new NotSupportedException();
|
||||
}
|
||||
|
||||
private static AclDefaults Defaults() => new()
|
||||
{
|
||||
Bronorganisatie = "517439943",
|
||||
VerantwoordelijkeOrganisatie = "517439943",
|
||||
Vertrouwelijkheidaanduiding = "openbaar",
|
||||
ZaaktypeIdentificatie = "BIG-REGISTRATIE",
|
||||
InformatieobjecttypeOmschrijving = "Diploma",
|
||||
};
|
||||
|
||||
[Fact]
|
||||
public async Task Resolves_the_zaaktype_and_informatieobjecttype_by_their_configured_business_keys()
|
||||
{
|
||||
var gateway = new ResolvingGateway();
|
||||
var catalog = new CachedZaaktypeCatalog(gateway, Defaults());
|
||||
|
||||
Assert.Equal(gateway.ZaaktypeUrl, await catalog.GetZaaktypeUrlAsync());
|
||||
Assert.Equal(gateway.InformatieobjecttypeUrl, await catalog.GetInformatieobjecttypeUrlAsync());
|
||||
Assert.Equal("BIG-REGISTRATIE", gateway.LastIdentificatie);
|
||||
Assert.Equal("Diploma", gateway.LastOmschrijving);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Caches_the_resolved_urls_so_the_gateway_is_hit_once()
|
||||
{
|
||||
var gateway = new ResolvingGateway();
|
||||
var catalog = new CachedZaaktypeCatalog(gateway, Defaults());
|
||||
|
||||
for (var i = 0; i < 3; i++)
|
||||
{
|
||||
await catalog.GetZaaktypeUrlAsync();
|
||||
await catalog.GetInformatieobjecttypeUrlAsync();
|
||||
}
|
||||
|
||||
Assert.Equal(1, gateway.ZaaktypeCalls);
|
||||
Assert.Equal(1, gateway.InformatieobjecttypeCalls);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Does_not_cache_a_failed_resolution_so_it_is_retried()
|
||||
{
|
||||
// The zaaktype is not published yet on the first call; the catalog must retry (not cache the
|
||||
// failure) so a later call succeeds once it is published.
|
||||
var gateway = new ResolvingGateway { ThrowZaaktypeTimes = 1 };
|
||||
var catalog = new CachedZaaktypeCatalog(gateway, Defaults());
|
||||
|
||||
await Assert.ThrowsAsync<InvalidOperationException>(() => catalog.GetZaaktypeUrlAsync());
|
||||
var url = await catalog.GetZaaktypeUrlAsync();
|
||||
|
||||
Assert.Equal(gateway.ZaaktypeUrl, url);
|
||||
Assert.Equal(2, gateway.ZaaktypeCalls);
|
||||
}
|
||||
}
|
||||
@@ -5,10 +5,6 @@ namespace Bff.Api;
|
||||
/// <summary>What the self-service submit returns to the portal (the domain's registration id + status).</summary>
|
||||
public sealed record SubmitAccepted(string RegistrationId, string Status);
|
||||
|
||||
/// <summary>The caller's current open registration, for resuming the self-service portal after a
|
||||
/// refresh (S-26): the reference (registration id) + its status.</summary>
|
||||
public sealed record CurrentRegistration(string RegistrationId, string Status);
|
||||
|
||||
/// <summary>A projection row as the projection-api serves it. <c>Bsn</c>/<c>NaamPlaceholder</c> are
|
||||
/// read but never surfaced by the openbaar endpoint (public-safe filtering, ADR-0010/S-09).
|
||||
/// <c>Reference</c> is the public-safe citizen reference (the zaak identificatie, #78).</summary>
|
||||
@@ -26,21 +22,11 @@ public interface IDomainClient
|
||||
{
|
||||
Task<SubmitAccepted> SubmitRegistrationAsync(string bsn, CancellationToken ct = default);
|
||||
|
||||
/// <summary>The caller's current open registration (resume after refresh, S-26), or <c>null</c>
|
||||
/// when they have none in flight. Owner-scoped by <paramref name="bsn"/>.</summary>
|
||||
Task<CurrentRegistration?> GetCurrentRegistrationAsync(string bsn, CancellationToken ct = default);
|
||||
|
||||
/// <summary>Withdraw the caller's own registration ("trek aanvraag in"). Owner-scoped by
|
||||
/// <paramref name="bsn"/>. Returns <c>false</c> when the domain reports the registration is
|
||||
/// unknown or not the caller's (404), so the BFF can relay a 404 rather than a 500.</summary>
|
||||
Task<bool> WithdrawRegistrationAsync(string registrationId, string bsn, CancellationToken ct = default);
|
||||
|
||||
/// <summary>Provide (upload) the diploma the caller's own registration is waiting for ("documenten
|
||||
/// aanleveren"). The file is carried base64-encoded. Owner-scoped by <paramref name="bsn"/>. Returns
|
||||
/// <c>false</c> when the domain reports the registration is unknown or not the caller's (404).</summary>
|
||||
Task<bool> ProvideDocumentsAsync(
|
||||
string registrationId, string bsn, string contentBase64, string? fileName, string? contentType, CancellationToken ct = default);
|
||||
|
||||
/// <summary>The behandelaar's werkbak — registrations awaiting beoordeling.</summary>
|
||||
Task<IReadOnlyList<WerkbakItem>> GetWerkbakAsync(CancellationToken ct = default);
|
||||
|
||||
@@ -66,18 +52,6 @@ public sealed class DomainClient(HttpClient http) : IDomainClient
|
||||
return new SubmitAccepted(dto.RegistrationId, dto.Status);
|
||||
}
|
||||
|
||||
public async Task<CurrentRegistration?> GetCurrentRegistrationAsync(string bsn, CancellationToken ct = default)
|
||||
{
|
||||
using var response = await http.GetAsync($"registrations/current?bsn={Uri.EscapeDataString(bsn)}", ct);
|
||||
// The domain 404s when the citizen has no open registration — that's "none", not an error.
|
||||
if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
|
||||
return null;
|
||||
response.EnsureSuccessStatusCode();
|
||||
var dto = await response.Content.ReadFromJsonAsync<DomainResponse>(ct)
|
||||
?? throw new InvalidOperationException("The Domain Service returned an empty registration response.");
|
||||
return new CurrentRegistration(dto.RegistrationId, dto.Status);
|
||||
}
|
||||
|
||||
public async Task<bool> WithdrawRegistrationAsync(string registrationId, string bsn, CancellationToken ct = default)
|
||||
{
|
||||
using var response = await http.PostAsJsonAsync(
|
||||
@@ -89,19 +63,6 @@ public sealed class DomainClient(HttpClient http) : IDomainClient
|
||||
return true;
|
||||
}
|
||||
|
||||
public async Task<bool> ProvideDocumentsAsync(
|
||||
string registrationId, string bsn, string contentBase64, string? fileName, string? contentType, CancellationToken ct = default)
|
||||
{
|
||||
using var response = await http.PostAsJsonAsync(
|
||||
$"registrations/{registrationId}/documents",
|
||||
new { bsn, contentBase64, fileName, contentType }, ct);
|
||||
// The domain 404s an unknown or not-owned registration; relay that rather than fail hard.
|
||||
if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
|
||||
return false;
|
||||
response.EnsureSuccessStatusCode();
|
||||
return true;
|
||||
}
|
||||
|
||||
public async Task<IReadOnlyList<WerkbakItem>> GetWerkbakAsync(CancellationToken ct = default)
|
||||
=> await http.GetFromJsonAsync<List<WerkbakItem>>("behandel/werkbak", ct) ?? [];
|
||||
|
||||
|
||||
@@ -86,24 +86,6 @@ app.MapPost("/self-service/registrations", async (ClaimsPrincipal user, IDomainC
|
||||
.Produces(StatusCodes.Status400BadRequest)
|
||||
.Produces(StatusCodes.Status401Unauthorized);
|
||||
|
||||
// Self-service resume (S-26): the signed-in zorgprofessional's current open registration, so the
|
||||
// portal can restore its reference + actions after a page refresh. The bsn comes from the DigiD token;
|
||||
// 204 when the citizen has none in flight (so the portal shows the submit form).
|
||||
app.MapGet("/self-service/registrations", async (ClaimsPrincipal user, IDomainClient domain, CancellationToken ct) =>
|
||||
{
|
||||
var bsn = user.FindFirstValue("bsn");
|
||||
if (string.IsNullOrWhiteSpace(bsn))
|
||||
return Results.BadRequest("The token carries no bsn claim.");
|
||||
|
||||
var current = await domain.GetCurrentRegistrationAsync(bsn, ct);
|
||||
return current is null ? Results.NoContent() : Results.Ok(current);
|
||||
})
|
||||
.RequireAuthorization()
|
||||
.Produces<CurrentRegistration>(StatusCodes.Status200OK)
|
||||
.Produces(StatusCodes.Status204NoContent)
|
||||
.Produces(StatusCodes.Status400BadRequest)
|
||||
.Produces(StatusCodes.Status401Unauthorized);
|
||||
|
||||
// Self-service withdrawal (S-11): the signed-in zorgprofessional withdraws their own registration.
|
||||
// The bsn comes from the DigiD token and is forwarded to the domain, which owner-scopes the action;
|
||||
// a registration that is unknown or not the caller's comes back 404 (ownership is not revealed).
|
||||
@@ -122,28 +104,6 @@ app.MapPost("/self-service/registrations/{id}/withdraw", async (string id, Claim
|
||||
.Produces(StatusCodes.Status401Unauthorized)
|
||||
.Produces(StatusCodes.Status404NotFound);
|
||||
|
||||
// Self-service provide-documents (S-10a): the signed-in zorgprofessional supplies the documents their
|
||||
// registration is waiting for ("documenten aanleveren"). The bsn comes from the DigiD token and is
|
||||
// forwarded to the domain, which owner-scopes the action and completes the WachtOpDocumenten task; a
|
||||
// registration that is unknown or not the caller's comes back 404. The real file upload + ZGW storage
|
||||
// is S-10b — this is the trigger that unblocks the process.
|
||||
app.MapPost("/self-service/registrations/{id}/documents", async (string id, ProvideDocumentsRequest body, ClaimsPrincipal user, IDomainClient domain, CancellationToken ct) =>
|
||||
{
|
||||
var bsn = user.FindFirstValue("bsn");
|
||||
if (string.IsNullOrWhiteSpace(bsn))
|
||||
return Results.BadRequest("The token carries no bsn claim.");
|
||||
if (string.IsNullOrWhiteSpace(body?.ContentBase64))
|
||||
return Results.BadRequest("A document is required.");
|
||||
|
||||
var provided = await domain.ProvideDocumentsAsync(id, bsn, body.ContentBase64, body.FileName, body.ContentType, ct);
|
||||
return provided ? Results.NoContent() : Results.NotFound();
|
||||
})
|
||||
.RequireAuthorization()
|
||||
.Produces(StatusCodes.Status204NoContent)
|
||||
.Produces(StatusCodes.Status400BadRequest)
|
||||
.Produces(StatusCodes.Status401Unauthorized)
|
||||
.Produces(StatusCodes.Status404NotFound);
|
||||
|
||||
// Openbaar register: an anonymous public lookup that exposes only public-safe fields (S-09).
|
||||
app.MapGet("/openbaar/register", async (string? q, IProjectionClient projection, CancellationToken ct) =>
|
||||
{
|
||||
@@ -183,10 +143,6 @@ app.Run();
|
||||
/// <summary>The behandelaar's decision on a registration.</summary>
|
||||
public sealed record DecideRequest(string Besluit);
|
||||
|
||||
/// <summary>A diploma upload from the self-service portal — the file base64-encoded client-side, with
|
||||
/// its name and MIME type. The bsn is taken from the DigiD token, not this body.</summary>
|
||||
public sealed record ProvideDocumentsRequest(string ContentBase64, string? FileName = null, string? ContentType = null);
|
||||
|
||||
// Behandel (medewerker-realm) authentication + authorization wiring (ADR-0013).
|
||||
internal static class BehandelAuth
|
||||
{
|
||||
|
||||
@@ -82,18 +82,6 @@ internal sealed class FakeDomainClient : IDomainClient
|
||||
return Task.FromResult(Result);
|
||||
}
|
||||
|
||||
public string? CurrentQueriedBsn { get; private set; }
|
||||
|
||||
/// <summary>The current open registration the fake domain returns (null → the citizen has none in
|
||||
/// flight, so the BFF replies 204). Tests set this to exercise resume.</summary>
|
||||
public CurrentRegistration? Current { get; set; }
|
||||
|
||||
public Task<CurrentRegistration?> GetCurrentRegistrationAsync(string bsn, CancellationToken ct = default)
|
||||
{
|
||||
CurrentQueriedBsn = bsn;
|
||||
return Task.FromResult(Current);
|
||||
}
|
||||
|
||||
public (string RegistrationId, string Bsn)? Withdrawn { get; private set; }
|
||||
|
||||
/// <summary>Whether the fake domain reports the withdrawal as done (true → 204) or not-found/not-owned
|
||||
@@ -106,18 +94,6 @@ internal sealed class FakeDomainClient : IDomainClient
|
||||
return Task.FromResult(WithdrawSucceeds);
|
||||
}
|
||||
|
||||
public (string RegistrationId, string Bsn, string ContentBase64, string? FileName, string? ContentType)? DocumentsProvidedFor { get; private set; }
|
||||
|
||||
/// <summary>Whether the fake domain reports the provide-documents as done (true → 204) or
|
||||
/// not-found/not-owned (false → 404). Tests set this to exercise the relay.</summary>
|
||||
public bool ProvideDocumentsSucceeds { get; set; } = true;
|
||||
|
||||
public Task<bool> ProvideDocumentsAsync(string registrationId, string bsn, string contentBase64, string? fileName, string? contentType, CancellationToken ct = default)
|
||||
{
|
||||
DocumentsProvidedFor = (registrationId, bsn, contentBase64, fileName, contentType);
|
||||
return Task.FromResult(ProvideDocumentsSucceeds);
|
||||
}
|
||||
|
||||
public (string RegistrationId, string Besluit)? Decided { get; private set; }
|
||||
|
||||
public Task<IReadOnlyList<WerkbakItem>> GetWerkbakAsync(CancellationToken ct = default)
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
using System.Net;
|
||||
using System.Net.Http.Headers;
|
||||
using System.Net.Http.Json;
|
||||
using Bff.Api;
|
||||
|
||||
namespace Bff.Tests;
|
||||
|
||||
@@ -113,108 +112,5 @@ public class SelfServiceEndpointTests
|
||||
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
|
||||
}
|
||||
|
||||
private static HttpRequestMessage ProvideDocuments(string? bearer, string id = "reg-123")
|
||||
{
|
||||
var request = new HttpRequestMessage(HttpMethod.Post, $"/self-service/registrations/{id}/documents")
|
||||
{
|
||||
// The portal base64-encodes the file client-side and posts it as JSON (S-10b); the bsn is
|
||||
// never in the body — it comes from the DigiD token.
|
||||
Content = JsonContent.Create(new
|
||||
{
|
||||
contentBase64 = Convert.ToBase64String([1, 2, 3]),
|
||||
fileName = "diploma.pdf",
|
||||
contentType = "application/pdf",
|
||||
}),
|
||||
};
|
||||
if (bearer is not null)
|
||||
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", bearer);
|
||||
return request;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Rejects_providing_documents_without_a_token()
|
||||
{
|
||||
using var factory = new BffFactory();
|
||||
|
||||
var response = await factory.CreateClient().SendAsync(ProvideDocuments(bearer: null));
|
||||
|
||||
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
|
||||
Assert.Null(factory.Domain.DocumentsProvidedFor);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Provides_documents_for_the_callers_registration_forwarding_id_bsn_and_file()
|
||||
{
|
||||
using var factory = new BffFactory();
|
||||
|
||||
var response = await factory.CreateClient().SendAsync(ProvideDocuments(TestTokens.Valid("123456782"), "reg-9"));
|
||||
|
||||
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
|
||||
var provided = factory.Domain.DocumentsProvidedFor;
|
||||
Assert.NotNull(provided);
|
||||
Assert.Equal("reg-9", provided!.Value.RegistrationId);
|
||||
Assert.Equal("123456782", provided.Value.Bsn);
|
||||
Assert.Equal(Convert.ToBase64String([1, 2, 3]), provided.Value.ContentBase64);
|
||||
Assert.Equal("diploma.pdf", provided.Value.FileName);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Relays_not_found_providing_documents_for_an_unknown_or_not_owned_registration()
|
||||
{
|
||||
using var factory = new BffFactory();
|
||||
factory.Domain.ProvideDocumentsSucceeds = false;
|
||||
|
||||
var response = await factory.CreateClient().SendAsync(ProvideDocuments(TestTokens.Valid("123456782")));
|
||||
|
||||
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
|
||||
}
|
||||
|
||||
private static HttpRequestMessage Current(string? bearer)
|
||||
{
|
||||
var request = new HttpRequestMessage(HttpMethod.Get, "/self-service/registrations");
|
||||
if (bearer is not null)
|
||||
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", bearer);
|
||||
return request;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Rejects_the_current_registration_lookup_without_a_token()
|
||||
{
|
||||
using var factory = new BffFactory();
|
||||
|
||||
var response = await factory.CreateClient().SendAsync(Current(bearer: null));
|
||||
|
||||
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Returns_no_content_when_the_caller_has_no_open_registration()
|
||||
{
|
||||
using var factory = new BffFactory();
|
||||
factory.Domain.Current = null;
|
||||
|
||||
var response = await factory.CreateClient().SendAsync(Current(TestTokens.Valid("123456782")));
|
||||
|
||||
Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
|
||||
Assert.Equal("123456782", factory.Domain.CurrentQueriedBsn);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Returns_the_callers_current_registration_when_one_is_open()
|
||||
{
|
||||
using var factory = new BffFactory();
|
||||
factory.Domain.Current = new CurrentRegistration("reg-77", "Ingediend");
|
||||
|
||||
var response = await factory.CreateClient().SendAsync(Current(TestTokens.Valid("123456782")));
|
||||
|
||||
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
|
||||
Assert.Equal("123456782", factory.Domain.CurrentQueriedBsn);
|
||||
var body = await response.Content.ReadFromJsonAsync<CurrentRegistrationDto>();
|
||||
Assert.Equal("reg-77", body!.RegistrationId);
|
||||
Assert.Equal("Ingediend", body.Status);
|
||||
}
|
||||
|
||||
private sealed record SubmitAcceptedDto(string RegistrationId, string Status);
|
||||
|
||||
private sealed record CurrentRegistrationDto(string RegistrationId, string Status);
|
||||
}
|
||||
|
||||
@@ -28,32 +28,6 @@
|
||||
"description": "Unauthorized"
|
||||
}
|
||||
}
|
||||
},
|
||||
"get": {
|
||||
"tags": [
|
||||
"Bff.Api"
|
||||
],
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "OK",
|
||||
"content": {
|
||||
"application/json": {
|
||||
"schema": {
|
||||
"$ref": "#/components/schemas/CurrentRegistration"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"204": {
|
||||
"description": "No Content"
|
||||
},
|
||||
"400": {
|
||||
"description": "Bad Request"
|
||||
},
|
||||
"401": {
|
||||
"description": "Unauthorized"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"/self-service/registrations/{id}/withdraw": {
|
||||
@@ -87,47 +61,6 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"/self-service/registrations/{id}/documents": {
|
||||
"post": {
|
||||
"tags": [
|
||||
"Bff.Api"
|
||||
],
|
||||
"parameters": [
|
||||
{
|
||||
"name": "id",
|
||||
"in": "path",
|
||||
"required": true,
|
||||
"schema": {
|
||||
"type": "string"
|
||||
}
|
||||
}
|
||||
],
|
||||
"requestBody": {
|
||||
"content": {
|
||||
"application/json": {
|
||||
"schema": {
|
||||
"$ref": "#/components/schemas/ProvideDocumentsRequest"
|
||||
}
|
||||
}
|
||||
},
|
||||
"required": true
|
||||
},
|
||||
"responses": {
|
||||
"204": {
|
||||
"description": "No Content"
|
||||
},
|
||||
"400": {
|
||||
"description": "Bad Request"
|
||||
},
|
||||
"401": {
|
||||
"description": "Unauthorized"
|
||||
},
|
||||
"404": {
|
||||
"description": "Not Found"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"/openbaar/register": {
|
||||
"get": {
|
||||
"tags": [
|
||||
@@ -231,21 +164,6 @@
|
||||
},
|
||||
"components": {
|
||||
"schemas": {
|
||||
"CurrentRegistration": {
|
||||
"required": [
|
||||
"registrationId",
|
||||
"status"
|
||||
],
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"registrationId": {
|
||||
"type": "string"
|
||||
},
|
||||
"status": {
|
||||
"type": "string"
|
||||
}
|
||||
}
|
||||
},
|
||||
"DecideRequest": {
|
||||
"required": [
|
||||
"besluit"
|
||||
@@ -279,29 +197,6 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"ProvideDocumentsRequest": {
|
||||
"required": [
|
||||
"contentBase64"
|
||||
],
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"contentBase64": {
|
||||
"type": "string"
|
||||
},
|
||||
"fileName": {
|
||||
"type": [
|
||||
"null",
|
||||
"string"
|
||||
]
|
||||
},
|
||||
"contentType": {
|
||||
"type": [
|
||||
"null",
|
||||
"string"
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
"SubmitAccepted": {
|
||||
"required": [
|
||||
"registrationId",
|
||||
|
||||
@@ -21,30 +21,18 @@ 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();
|
||||
|
||||
@@ -55,12 +43,7 @@ app.MapGet("/health", () => "Healthy");
|
||||
// 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);
|
||||
var id = await submit.HandleAsync(new SubmitRegistrationCommand(body.Bsn), ct);
|
||||
return Results.Accepted($"/registrations/{id}", new RegistrationResponse(id.ToString(), RegistrationStatus.Ingediend.ToString(), null));
|
||||
});
|
||||
|
||||
@@ -108,32 +91,6 @@ app.MapPost("/registrations/{id}/withdraw", async (string id, WithdrawRequest bo
|
||||
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).
|
||||
@@ -141,21 +98,6 @@ 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).
|
||||
// The citizen's current open registration, looked up by bsn — lets the self-service portal resume
|
||||
// after a refresh (S-26). The BFF forwards the bsn from the DigiD token; the domain trusts its
|
||||
// callers (§8.3). 404 when the citizen has none in flight.
|
||||
app.MapGet("/registrations/current", async (string bsn, IRegistrationStore store, CancellationToken ct) =>
|
||||
{
|
||||
if (string.IsNullOrWhiteSpace(bsn))
|
||||
return Results.BadRequest("A bsn is required.");
|
||||
|
||||
var registration = await store.FindOpenByBsnAsync(bsn, ct);
|
||||
return registration is null
|
||||
? Results.NotFound()
|
||||
: Results.Ok(new RegistrationResponse(
|
||||
registration.Id.ToString(), registration.Status.ToString(), registration.ZaakUrl?.ToString()));
|
||||
});
|
||||
|
||||
app.MapGet("/registrations/{id}", async (string id, IRegistrationStore store, CancellationToken ct) =>
|
||||
{
|
||||
if (!Guid.TryParse(id, out var guid))
|
||||
@@ -170,14 +112,12 @@ app.MapGet("/registrations/{id}", async (string id, IRegistrationStore store, Ca
|
||||
|
||||
await app.RunAsync();
|
||||
|
||||
public sealed record SubmitRegistrationRequest(string Bsn, string? DiplomaOrigin = null);
|
||||
public sealed record SubmitRegistrationRequest(string Bsn);
|
||||
|
||||
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;
|
||||
|
||||
@@ -1,45 +0,0 @@
|
||||
using Big.Domain;
|
||||
|
||||
namespace Big.Application;
|
||||
|
||||
/// <summary>
|
||||
/// Handles one acquired <c>RegistratieVerlopen</c> external-worker job (S-10a, ADR-0017): load the
|
||||
/// registration the job correlates to and expire it to VERLOPEN — the 30-day document-wait timer fired
|
||||
/// before the documents arrived, so the case is cancelled. Pure application logic over ports; it knows
|
||||
/// nothing of Flowable. The polling loop that feeds it jobs lives in Infrastructure. Mirrors
|
||||
/// <see cref="OpenZaakWorker"/>.
|
||||
/// </summary>
|
||||
public sealed class ExpireRegistrationWorker(IRegistrationStore store, IAclClient acl)
|
||||
{
|
||||
/// <summary>
|
||||
/// Process the job. Idempotent and tolerant of races (§8.6, at-least-once delivery): a job whose
|
||||
/// registration is already resolved — a redelivered expiry (VERLOPEN), or one withdrawn/decided
|
||||
/// while it waited (INGETROKKEN/INGESCHREVEN/AFGEWEZEN) — is a no-op, so the job still completes
|
||||
/// rather than throwing into a redelivery loop. Only a still-open registration is expired. An
|
||||
/// unknown registration is an error: it throws, leaving the job un-completed for Flowable to redeliver.
|
||||
/// </summary>
|
||||
public async Task HandleAsync(RegistratieVerlopenJob job, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(job);
|
||||
|
||||
var registration = await store.GetAsync(job.RegistrationId, ct)
|
||||
?? throw new InvalidOperationException(
|
||||
$"No registration {job.RegistrationId} for RegistratieVerlopen job {job.JobId}.");
|
||||
|
||||
// Only a still-open registration lapses; an already-resolved one (expired, or withdrawn/decided
|
||||
// while it waited) is left untouched so the job can complete without violating the aggregate.
|
||||
if (registration.Status is not (RegistrationStatus.Ingediend or RegistrationStatus.InBehandeling))
|
||||
return;
|
||||
|
||||
// Cancel the ZGW zaak before advancing the aggregate (mirrors the approval path): if the ACL
|
||||
// call fails it throws, the aggregate stays open, and the job is redelivered (§8.6) — rather
|
||||
// than leaving the aggregate VERLOPEN while the zaak stays open. The status guard above stops a
|
||||
// redelivered job from cancelling the zaak twice (a second resultaat would be a 400). A
|
||||
// registration expired before its zaak was opened has nothing to cancel.
|
||||
if (registration.ZaakUrl is not null)
|
||||
await acl.CancelZaakAsync(registration.ZaakUrl, ct);
|
||||
|
||||
registration.Expire();
|
||||
await store.SaveAsync(registration, ct);
|
||||
}
|
||||
}
|
||||
@@ -11,12 +11,10 @@ public interface IWorkflowClient
|
||||
{
|
||||
/// <summary>
|
||||
/// Start one <c>registratie</c> process instance for the given registration, carrying the
|
||||
/// registration id (so the <c>OpenZaakAanmaken</c> external task can be correlated back to its
|
||||
/// aggregate) and the diploma origin (so the workflow's DMN can route foreign diplomas through
|
||||
/// CBGV-advies, S-13). Returns the process instance id.
|
||||
/// registration id so the <c>OpenZaakAanmaken</c> external task can be correlated back to its
|
||||
/// aggregate. Returns the process instance id.
|
||||
/// </summary>
|
||||
Task<string> StartRegistrationProcessAsync(
|
||||
RegistrationId registrationId, DiplomaOrigin diplomaOrigin, CancellationToken ct = default);
|
||||
Task<string> StartRegistrationProcessAsync(RegistrationId registrationId, CancellationToken ct = default);
|
||||
|
||||
/// <summary>
|
||||
/// Cancel a running <c>registratie</c> process on withdrawal (S-11): correlate the
|
||||
@@ -25,14 +23,6 @@ public interface IWorkflowClient
|
||||
/// ended, or not yet parked) it is a no-op; the aggregate is INGETROKKEN regardless.
|
||||
/// </summary>
|
||||
Task WithdrawProcessAsync(string processInstanceId, CancellationToken ct = default);
|
||||
|
||||
/// <summary>
|
||||
/// Signal that the required documents have arrived (S-10a): complete the <c>WachtOpDocumenten</c>
|
||||
/// user task in the instance so the process leaves the 30-day wait state and continues to
|
||||
/// beoordeling (ADR-0017). Best-effort — if the instance is not parked at that task (already
|
||||
/// continued, or timed out) it is a no-op. The upload trigger that calls this is wired in S-10b.
|
||||
/// </summary>
|
||||
Task CompleteDocumentWaitAsync(string processInstanceId, CancellationToken ct = default);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -52,19 +42,6 @@ public interface IAclClient
|
||||
/// the zaak's final status — which OpenZaak notifies over NRC; the domain never names statustypen.
|
||||
/// </summary>
|
||||
Task ApproveZaakAsync(Uri zaakUrl, CancellationToken ct = default);
|
||||
|
||||
/// <summary>
|
||||
/// Store an uploaded diploma against the zaak (S-10b). The domain hands over the zaak, the raw file
|
||||
/// bytes, and the file's name/type; the ACL creates the ZGW informatieobject and relates it to the
|
||||
/// zaak (§8.1). Returns the stored document's URL.
|
||||
/// </summary>
|
||||
Task<Uri> StoreDiplomaAsync(Uri zaakUrl, byte[] content, string fileName, string contentType, CancellationToken ct = default);
|
||||
|
||||
/// <summary>
|
||||
/// Cancel the zaak on document-timeout expiry (S-10c): the 30-day document term lapsed, so the ACL
|
||||
/// translates this to the ZGW cancellation status/resultaat. The domain never names statustypen.
|
||||
/// </summary>
|
||||
Task CancelZaakAsync(Uri zaakUrl, CancellationToken ct = default);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -102,11 +79,6 @@ public interface IRegistrationStore
|
||||
|
||||
/// <summary>Load a registration by id, or <c>null</c> if none exists.</summary>
|
||||
Task<Registration?> GetAsync(RegistrationId id, CancellationToken ct = default);
|
||||
|
||||
/// <summary>The citizen's current <em>open</em> (non-terminal: INGEDIEND/IN_BEHANDELING)
|
||||
/// registration, or <c>null</c> if they have none in flight. Lets the self-service portal resume
|
||||
/// an existing registration after a refresh (S-26); terminal registrations are not resumed.</summary>
|
||||
Task<Registration?> FindOpenByBsnAsync(string bsn, CancellationToken ct = default);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
@@ -114,18 +86,3 @@ public interface IRegistrationStore
|
||||
/// it) and the registration id it carries as a process variable.
|
||||
/// </summary>
|
||||
public sealed record OpenZaakJob(string JobId, RegistrationId RegistrationId);
|
||||
|
||||
/// <summary>
|
||||
/// An acquired <c>BeoordelingEscaleren</c> escalation job (S-14): the Flowable job id and the process
|
||||
/// instance whose still-open <c>Beoordelen</c> task must be reassigned from behandelaar to teamlead
|
||||
/// once the 14-day boundary timer fires (ADR-0015).
|
||||
/// </summary>
|
||||
public sealed record EscalatieJob(string JobId, string ProcessInstanceId);
|
||||
|
||||
/// <summary>
|
||||
/// An acquired <c>RegistratieVerlopen</c> job (S-10a): the Flowable job id and the registration id it
|
||||
/// carries as a process variable. The 30-day boundary timer on <c>WachtOpDocumenten</c> spawns it when
|
||||
/// the required documents were not supplied in time; expiring the correlated registration to VERLOPEN
|
||||
/// cancels the case (ADR-0017).
|
||||
/// </summary>
|
||||
public sealed record RegistratieVerlopenJob(string JobId, RegistrationId RegistrationId);
|
||||
|
||||
@@ -1,54 +0,0 @@
|
||||
using Big.Domain;
|
||||
|
||||
namespace Big.Application;
|
||||
|
||||
/// <summary>A zorgprofessional's upload of the diploma their registration is waiting for ("documenten
|
||||
/// aanleveren"). <paramref name="Bsn"/> is the authenticated caller (from the DigiD token, forwarded by
|
||||
/// the BFF): only the registration's own bsn may provide its documents. <paramref name="Content"/> is
|
||||
/// the raw file, with its <paramref name="FileName"/> and <paramref name="ContentType"/>.</summary>
|
||||
public sealed record ProvideDocumentsCommand(
|
||||
RegistrationId RegistrationId, string Bsn, byte[] Content, string FileName, string ContentType);
|
||||
|
||||
/// <summary>The outcome of a provide-documents request.</summary>
|
||||
public enum ProvideDocumentsOutcome
|
||||
{
|
||||
/// <summary>The documents were accepted; the process's document wait was completed (if any).</summary>
|
||||
Accepted,
|
||||
|
||||
/// <summary>No registration with that id belongs to the caller — unknown, or owned by someone else
|
||||
/// (the two are deliberately indistinguishable, so the endpoint reveals neither).</summary>
|
||||
NotFound,
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The provide-documents use case (S-10a/S-10b): a zorgprofessional uploads the diploma their
|
||||
/// registration is parked waiting for. The document is stored in ZGW via the ACL (§8.1), then the
|
||||
/// WachtOpDocumenten task is completed so the registratie process leaves the 30-day wait and continues
|
||||
/// to beoordeling (ADR-0017). Owner-scoped by bsn. Both steps are best-effort about missing preconditions
|
||||
/// (mirroring <see cref="WithdrawRegistration"/>): storage needs an opened zaak, and completion needs a
|
||||
/// running process — a request that arrives before either still stands, storing/completing what it can.
|
||||
/// </summary>
|
||||
public sealed class ProvideDocuments(IRegistrationStore store, IWorkflowClient workflow, IAclClient acl)
|
||||
{
|
||||
public async Task<ProvideDocumentsOutcome> HandleAsync(ProvideDocumentsCommand command, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(command);
|
||||
|
||||
var registration = await store.GetAsync(command.RegistrationId, ct);
|
||||
|
||||
// Unknown, or not the caller's registration: report NotFound either way (don't reveal which).
|
||||
if (registration is null || registration.Bsn != command.Bsn)
|
||||
return ProvideDocumentsOutcome.NotFound;
|
||||
|
||||
// Store the diploma against the zaak (once it is opened) — the ACL is the only ZGW caller (§8.1).
|
||||
if (registration.ZaakUrl is not null)
|
||||
await acl.StoreDiplomaAsync(
|
||||
registration.ZaakUrl, command.Content, command.FileName, command.ContentType, ct);
|
||||
|
||||
// Complete the document wait (if a process is running) so beoordeling can proceed.
|
||||
if (registration.ProcessInstanceId is not null)
|
||||
await workflow.CompleteDocumentWaitAsync(registration.ProcessInstanceId, ct);
|
||||
|
||||
return ProvideDocumentsOutcome.Accepted;
|
||||
}
|
||||
}
|
||||
@@ -2,10 +2,8 @@ using Big.Domain;
|
||||
|
||||
namespace Big.Application;
|
||||
|
||||
/// <summary>A zorgprofessional's request to register, in domain language. No ZGW concepts. The
|
||||
/// diploma origin defaults to domestic (the DigiD path); a foreign (eIDAS) submission sets it to
|
||||
/// <see cref="DiplomaOrigin.Buitenlands"/> so the workflow's DMN routes it through CBGV-advies (S-13).</summary>
|
||||
public sealed record SubmitRegistrationCommand(string Bsn, DiplomaOrigin DiplomaOrigin = DiplomaOrigin.Binnenlands);
|
||||
/// <summary>A zorgprofessional's request to register, in domain language. No ZGW concepts.</summary>
|
||||
public sealed record SubmitRegistrationCommand(string Bsn);
|
||||
|
||||
/// <summary>
|
||||
/// The submit use case: create the <see cref="Registration"/> aggregate (INGEDIEND), persist it,
|
||||
@@ -20,14 +18,13 @@ public sealed class SubmitRegistration(IRegistrationStore store, IWorkflowClient
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(command);
|
||||
|
||||
var registration = Registration.Submit(command.Bsn, command.DiplomaOrigin);
|
||||
var registration = Registration.Submit(command.Bsn);
|
||||
|
||||
// Persist before starting the process so the worker can correlate the OpenZaakAanmaken
|
||||
// job back to an aggregate that already exists (ADR-0009).
|
||||
await store.SaveAsync(registration, ct);
|
||||
|
||||
var processInstanceId = await workflow.StartRegistrationProcessAsync(
|
||||
registration.Id, registration.DiplomaOrigin, ct);
|
||||
var processInstanceId = await workflow.StartRegistrationProcessAsync(registration.Id, ct);
|
||||
registration.RecordProcessStarted(processInstanceId);
|
||||
await store.SaveAsync(registration, ct);
|
||||
|
||||
|
||||
@@ -1,17 +0,0 @@
|
||||
namespace Big.Domain;
|
||||
|
||||
/// <summary>
|
||||
/// Where a zorgprofessional's diploma was issued. It is the input to the diploma-eligibility decision
|
||||
/// (S-13): a <see cref="Buitenlands"/> (foreign) diploma routes the registratie through an extra
|
||||
/// CBGV-advies assessment step, a <see cref="Binnenlands"/> (domestic) one goes straight to beoordeling.
|
||||
/// The decision itself lives in the workflow's DMN, not here (ADR-0016); the domain only carries the
|
||||
/// origin and hands it to the process as a start variable.
|
||||
/// </summary>
|
||||
public enum DiplomaOrigin
|
||||
{
|
||||
/// <summary>A Dutch (domestic) diploma. Default for a registration submitted via DigiD.</summary>
|
||||
Binnenlands,
|
||||
|
||||
/// <summary>A foreign diploma (e.g. an eIDAS submission). Triggers the CBGV-advies step.</summary>
|
||||
Buitenlands,
|
||||
}
|
||||
@@ -7,11 +7,10 @@ namespace Big.Domain;
|
||||
/// </summary>
|
||||
public sealed class Registration
|
||||
{
|
||||
private Registration(RegistrationId id, string bsn, DiplomaOrigin diplomaOrigin)
|
||||
private Registration(RegistrationId id, string bsn)
|
||||
{
|
||||
Id = id;
|
||||
Bsn = bsn;
|
||||
DiplomaOrigin = diplomaOrigin;
|
||||
Status = RegistrationStatus.Ingediend;
|
||||
}
|
||||
|
||||
@@ -21,10 +20,6 @@ public sealed class Registration
|
||||
/// as the domain payload; the domain never constructs ZGW concepts from it (§8.1).</summary>
|
||||
public string Bsn { get; }
|
||||
|
||||
/// <summary>Where the diploma was issued. Rides along to the process as a start variable and
|
||||
/// drives the diploma-eligibility DMN's foreign→CBGV-advies routing (S-13, ADR-0016).</summary>
|
||||
public DiplomaOrigin DiplomaOrigin { get; }
|
||||
|
||||
public RegistrationStatus Status { get; private set; }
|
||||
|
||||
/// <summary>The Flowable process instance driving this registration, once started.</summary>
|
||||
@@ -33,13 +28,11 @@ public sealed class Registration
|
||||
/// <summary>The zaak the ACL opened for this registration, once the external task has run.</summary>
|
||||
public Uri? ZaakUrl { get; private set; }
|
||||
|
||||
/// <summary>Submit a new registration. It begins in <see cref="RegistrationStatus.Ingediend"/>.
|
||||
/// The diploma origin defaults to <see cref="DiplomaOrigin.Binnenlands"/> — the common DigiD path;
|
||||
/// a foreign (eIDAS) submission passes <see cref="DiplomaOrigin.Buitenlands"/>.</summary>
|
||||
public static Registration Submit(string bsn, DiplomaOrigin diplomaOrigin = DiplomaOrigin.Binnenlands)
|
||||
/// <summary>Submit a new registration. It begins in <see cref="RegistrationStatus.Ingediend"/>.</summary>
|
||||
public static Registration Submit(string bsn)
|
||||
{
|
||||
ArgumentException.ThrowIfNullOrWhiteSpace(bsn);
|
||||
return new Registration(RegistrationId.New(), bsn, diplomaOrigin);
|
||||
return new Registration(RegistrationId.New(), bsn);
|
||||
}
|
||||
|
||||
/// <summary>Record that the registratie workflow process has been started for this registration.</summary>
|
||||
@@ -133,24 +126,8 @@ public sealed class Registration
|
||||
Status = RegistrationStatus.Ingetrokken;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Expire the registration — the 30-day document-wait timer fired before the required documents
|
||||
/// were supplied, so the registratie process cancels the case (S-10a). Allowed while it is still
|
||||
/// open (INGEDIEND or IN_BEHANDELING) and needs no zaak; a decided (INGESCHREVEN/AFGEWEZEN) or
|
||||
/// withdrawn (INGETROKKEN) registration can no longer expire. Re-expiring one already
|
||||
/// <see cref="RegistrationStatus.Verlopen"/> is a no-op — the worker job may be redelivered (§8.6).
|
||||
/// </summary>
|
||||
public void Expire()
|
||||
{
|
||||
if (Status == RegistrationStatus.Verlopen)
|
||||
return;
|
||||
|
||||
RequireOpenForDecision(nameof(Expire));
|
||||
Status = RegistrationStatus.Verlopen;
|
||||
}
|
||||
|
||||
// A decision (or withdrawal, or expiry) is only valid while the registration is still open
|
||||
// (INGEDIEND or IN_BEHANDELING).
|
||||
// A decision (or withdrawal) is only valid while the registration is still open (INGEDIEND or
|
||||
// IN_BEHANDELING).
|
||||
private void RequireOpenForDecision(string decision)
|
||||
{
|
||||
if (Status is not (RegistrationStatus.Ingediend or RegistrationStatus.InBehandeling))
|
||||
|
||||
@@ -21,8 +21,4 @@ public enum RegistrationStatus
|
||||
|
||||
/// <summary>Withdrawn by the zorgprofessional before a decision (S-11). Terminal.</summary>
|
||||
Ingetrokken,
|
||||
|
||||
/// <summary>Lapsed: the required documents were not supplied within the 30-day window, so the
|
||||
/// registratie process cancelled the case (S-10a). Terminal.</summary>
|
||||
Verlopen,
|
||||
}
|
||||
|
||||
@@ -31,32 +31,6 @@ public sealed class AclHttpClient(HttpClient http, AclOptions options) : IAclCli
|
||||
response.EnsureSuccessStatusCode();
|
||||
}
|
||||
|
||||
public async Task CancelZaakAsync(Uri zaakUrl, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(zaakUrl);
|
||||
|
||||
using var response = await http.PostAsJsonAsync(
|
||||
new Uri(options.BaseUrl, "annuleringen"), new CancelZaakRequest(zaakUrl.ToString()), ct);
|
||||
response.EnsureSuccessStatusCode();
|
||||
}
|
||||
|
||||
public async Task<Uri> StoreDiplomaAsync(Uri zaakUrl, byte[] content, string fileName, string contentType, CancellationToken ct = default)
|
||||
{
|
||||
ArgumentNullException.ThrowIfNull(zaakUrl);
|
||||
ArgumentNullException.ThrowIfNull(content);
|
||||
|
||||
// The file crosses this boundary base64-encoded in JSON — the domain and ACL contracts are
|
||||
// JSON, and a diploma is small (S-10b, ADR). The ACL turns it into a ZGW informatieobject.
|
||||
using var response = await http.PostAsJsonAsync(
|
||||
new Uri(options.BaseUrl, "documenten"),
|
||||
new StoreDocumentRequest(zaakUrl.ToString(), Convert.ToBase64String(content), fileName, contentType), ct);
|
||||
response.EnsureSuccessStatusCode();
|
||||
|
||||
var stored = await response.Content.ReadFromJsonAsync<StoreDocumentResponse>(ct)
|
||||
?? throw new InvalidOperationException("The ACL returned an empty document response.");
|
||||
return new Uri(stored.InformatieobjectUrl);
|
||||
}
|
||||
|
||||
private sealed record OpenZaakRequest(
|
||||
[property: JsonPropertyName("bsn")] string Bsn,
|
||||
[property: JsonPropertyName("reference")] string Reference);
|
||||
@@ -64,15 +38,4 @@ public sealed class AclHttpClient(HttpClient http, AclOptions options) : IAclCli
|
||||
private sealed record OpenZaakResponse([property: JsonPropertyName("zaakUrl")] string ZaakUrl);
|
||||
|
||||
private sealed record SetStatusRequest([property: JsonPropertyName("zaakUrl")] string ZaakUrl);
|
||||
|
||||
private sealed record CancelZaakRequest([property: JsonPropertyName("zaakUrl")] string ZaakUrl);
|
||||
|
||||
private sealed record StoreDocumentRequest(
|
||||
[property: JsonPropertyName("zaakUrl")] string ZaakUrl,
|
||||
[property: JsonPropertyName("contentBase64")] string ContentBase64,
|
||||
[property: JsonPropertyName("fileName")] string FileName,
|
||||
[property: JsonPropertyName("contentType")] string ContentType);
|
||||
|
||||
private sealed record StoreDocumentResponse(
|
||||
[property: JsonPropertyName("informatieobjectUrl")] string InformatieobjectUrl);
|
||||
}
|
||||
|
||||
@@ -1,37 +0,0 @@
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace Big.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// One poll tick of the beoordeling-escalation worker (S-14, ADR-0015): acquire the parked
|
||||
/// <c>BeoordelingEscaleren</c> jobs — the tokens the 14-day boundary timer on <c>Beoordelen</c> spawns
|
||||
/// — reassign each instance's still-open <c>Beoordelen</c> task to the teamlead, and complete the job.
|
||||
/// A job that fails is logged and left un-completed so Flowable redelivers it (§8.6). Split out from
|
||||
/// the hosted pump so the acquire→reassign→complete logic is unit-testable without a running host.
|
||||
/// </summary>
|
||||
public sealed class BeoordelingEscalatieProcessor(
|
||||
IBeoordelingEscalatieClient client,
|
||||
ILogger<BeoordelingEscalatieProcessor> logger)
|
||||
{
|
||||
/// <summary>Acquire and process up to <paramref name="maxJobs"/> escalations. Returns the number acquired.</summary>
|
||||
public async Task<int> PumpOnceAsync(int maxJobs, CancellationToken ct = default)
|
||||
{
|
||||
var jobs = await client.AcquireBeoordelingEscalatieJobsAsync(maxJobs, ct);
|
||||
|
||||
foreach (var job in jobs)
|
||||
{
|
||||
try
|
||||
{
|
||||
await client.ReassignBeoordelingToTeamleadAsync(job.ProcessInstanceId, ct);
|
||||
await client.CompleteBeoordelingEscalatieJobAsync(job.JobId, ct);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// Leave the job un-completed: its lock expires and Flowable redelivers it (§8.6).
|
||||
logger.LogError(ex, "BeoordelingEscaleren job {JobId} failed; leaving it for redelivery.", job.JobId);
|
||||
}
|
||||
}
|
||||
|
||||
return jobs.Count;
|
||||
}
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Hosting;
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace Big.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// The hosted polling loop of the beoordeling-escalation worker (S-14, ADR-0015): on an interval it
|
||||
/// resolves a scoped <see cref="BeoordelingEscalatieProcessor"/> and asks it to drain the parked
|
||||
/// <c>BeoordelingEscaleren</c> jobs. A deliberately thin shell — all acquire/reassign/complete logic
|
||||
/// lives in the processor, which is unit-tested; this class only owns the timer, the per-tick scope,
|
||||
/// and loop resilience. Structurally identical to <see cref="OpenZaakJobPump"/>.
|
||||
/// </summary>
|
||||
public sealed class BeoordelingEscalatiePump(
|
||||
IServiceScopeFactory scopeFactory,
|
||||
FlowableOptions options,
|
||||
ILogger<BeoordelingEscalatiePump> logger) : BackgroundService
|
||||
{
|
||||
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
|
||||
{
|
||||
while (!stoppingToken.IsCancellationRequested)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var scope = scopeFactory.CreateScope();
|
||||
var processor = scope.ServiceProvider.GetRequiredService<BeoordelingEscalatieProcessor>();
|
||||
await processor.PumpOnceAsync(options.MaxJobsPerPoll, stoppingToken);
|
||||
}
|
||||
catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
|
||||
{
|
||||
break;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// A transient fault (e.g. Flowable briefly unreachable) must not kill the loop.
|
||||
logger.LogError(ex, "BeoordelingEscaleren job poll failed; retrying after the poll interval.");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
await Task.Delay(options.PollInterval, stoppingToken);
|
||||
}
|
||||
catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -15,31 +15,21 @@ namespace Big.Infrastructure;
|
||||
/// The REST contract here is the one verified against a live flowable-rest engine (ADR-0009).
|
||||
/// </summary>
|
||||
public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions options)
|
||||
: IWorkflowClient, IExternalWorkerClient, IUserTaskClient, IBeoordelingEscalatieClient, IRegistratieVerlopenClient
|
||||
: IWorkflowClient, IExternalWorkerClient, IUserTaskClient
|
||||
{
|
||||
private const string Topic = "OpenZaakAanmaken";
|
||||
private const string EscalatieTopic = "BeoordelingEscaleren";
|
||||
private const string VerlopenTopic = "RegistratieVerlopen";
|
||||
private const string ProcessDefinitionKey = "registratie";
|
||||
private const string BeoordelenTaskKey = "Beoordelen";
|
||||
private const string WachtOpDocumentenTaskKey = "WachtOpDocumenten";
|
||||
private const string BehandelaarGroup = "behandelaar";
|
||||
private const string TeamleadGroup = "teamlead";
|
||||
private const string RegistrationIdVariable = "registrationId";
|
||||
private const string DiplomaOriginVariable = "diplomaOrigin";
|
||||
private const string ZaakUrlVariable = "zaakUrl";
|
||||
private const string BesluitVariable = "besluit";
|
||||
private const string IngetrokkenMessage = "RegistratieIngetrokken";
|
||||
|
||||
public async Task<string> StartRegistrationProcessAsync(
|
||||
RegistrationId registrationId, DiplomaOrigin diplomaOrigin, CancellationToken ct = default)
|
||||
public async Task<string> StartRegistrationProcessAsync(RegistrationId registrationId, CancellationToken ct = default)
|
||||
{
|
||||
var request = new StartProcessRequest(
|
||||
ProcessDefinitionKey,
|
||||
[
|
||||
new Variable(RegistrationIdVariable, "string", registrationId.ToString()),
|
||||
new Variable(DiplomaOriginVariable, "string", diplomaOrigin.ToString()),
|
||||
]);
|
||||
[new Variable(RegistrationIdVariable, "string", registrationId.ToString())]);
|
||||
|
||||
var created = await PostAsync<StartProcessRequest, ProcessInstance>(
|
||||
"service/runtime/process-instances", request, ct)
|
||||
@@ -116,83 +106,6 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
|
||||
response.EnsureSuccessStatusCode();
|
||||
}
|
||||
|
||||
public async Task CompleteDocumentWaitAsync(string processInstanceId, CancellationToken ct = default)
|
||||
{
|
||||
// Find the still-open WachtOpDocumenten task in this instance and complete it, so the process
|
||||
// leaves the 30-day wait and continues to beoordeling (S-10a, ADR-0017). If the instance is no
|
||||
// longer parked there (already continued, or the timer already cancelled it) this is a
|
||||
// best-effort no-op — mirroring the withdrawal/escalation correlation (§8.6).
|
||||
var query = new TaskByInstanceQueryRequest(processInstanceId, WachtOpDocumentenTaskKey);
|
||||
var page = await PostAsync<TaskByInstanceQueryRequest, TaskQueryResult>(
|
||||
"service/query/tasks", query, ct);
|
||||
|
||||
var task = page?.Data?.FirstOrDefault();
|
||||
if (task is null)
|
||||
return;
|
||||
|
||||
using var response = await SendAsync(
|
||||
$"service/runtime/tasks/{task.Id}", new CompleteTaskRequest("complete", []), ct);
|
||||
response.EnsureSuccessStatusCode();
|
||||
}
|
||||
|
||||
public async Task<IReadOnlyList<EscalatieJob>> AcquireBeoordelingEscalatieJobsAsync(int maxJobs, CancellationToken ct = default)
|
||||
{
|
||||
var request = new AcquireJobsRequest(EscalatieTopic, options.LockDuration, maxJobs, options.WorkerId);
|
||||
|
||||
var jobs = await PostAsync<AcquireJobsRequest, List<AcquiredEscalatieJob>>(
|
||||
"external-job-api/acquire/jobs", request, ct) ?? [];
|
||||
|
||||
return [.. jobs.Select(job => new EscalatieJob(job.Id, job.ProcessInstanceId))];
|
||||
}
|
||||
|
||||
public async Task ReassignBeoordelingToTeamleadAsync(string processInstanceId, CancellationToken ct = default)
|
||||
{
|
||||
// The escalation token runs in parallel to the still-open Beoordelen task (non-interrupting
|
||||
// boundary timer); find that task in this instance so we can move it to the teamlead. If the
|
||||
// behandelaar completed it just before the timer fired there is nothing to reassign — a
|
||||
// best-effort no-op (the timer/completion race, cf. §8.6).
|
||||
var query = new TaskByInstanceQueryRequest(processInstanceId, BeoordelenTaskKey);
|
||||
var page = await PostAsync<TaskByInstanceQueryRequest, TaskQueryResult>(
|
||||
"service/query/tasks", query, ct);
|
||||
|
||||
var task = page?.Data?.FirstOrDefault();
|
||||
if (task is null)
|
||||
return;
|
||||
|
||||
// Add teamlead, then drop behandelaar: the task now belongs to the teamlead group.
|
||||
using (var added = await SendAsync(
|
||||
$"service/runtime/tasks/{task.Id}/identitylinks",
|
||||
new IdentityLinkRequest(TeamleadGroup, "candidate"), ct))
|
||||
added.EnsureSuccessStatusCode();
|
||||
|
||||
await DeleteAsync(
|
||||
$"service/runtime/tasks/{task.Id}/identitylinks/groups/{BehandelaarGroup}/candidate", ct);
|
||||
}
|
||||
|
||||
public async Task CompleteBeoordelingEscalatieJobAsync(string jobId, CancellationToken ct = default)
|
||||
{
|
||||
using var response = await SendAsync(
|
||||
$"external-job-api/acquire/jobs/{jobId}/complete", new CompleteJobRequest(options.WorkerId, []), ct);
|
||||
response.EnsureSuccessStatusCode();
|
||||
}
|
||||
|
||||
public async Task<IReadOnlyList<RegistratieVerlopenJob>> AcquireRegistratieVerlopenJobsAsync(int maxJobs, CancellationToken ct = default)
|
||||
{
|
||||
var request = new AcquireJobsRequest(VerlopenTopic, options.LockDuration, maxJobs, options.WorkerId);
|
||||
|
||||
var jobs = await PostAsync<AcquireJobsRequest, List<AcquiredJob>>(
|
||||
"external-job-api/acquire/jobs", request, ct) ?? [];
|
||||
|
||||
return [.. jobs.Select(job => new RegistratieVerlopenJob(job.Id, RegistrationId.Parse(job.RegistrationId())))];
|
||||
}
|
||||
|
||||
public async Task CompleteRegistratieVerlopenJobAsync(string jobId, CancellationToken ct = default)
|
||||
{
|
||||
using var response = await SendAsync(
|
||||
$"external-job-api/acquire/jobs/{jobId}/complete", new CompleteJobRequest(options.WorkerId, []), ct);
|
||||
response.EnsureSuccessStatusCode();
|
||||
}
|
||||
|
||||
private async Task<TResponse?> GetAsync<TResponse>(string path, CancellationToken ct)
|
||||
{
|
||||
var message = new HttpRequestMessage(HttpMethod.Get, new Uri(options.BaseUrl, path));
|
||||
@@ -202,14 +115,6 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
|
||||
return await response.Content.ReadFromJsonAsync<TResponse>(ct);
|
||||
}
|
||||
|
||||
private async Task DeleteAsync(string path, CancellationToken ct)
|
||||
{
|
||||
var message = new HttpRequestMessage(HttpMethod.Delete, new Uri(options.BaseUrl, path));
|
||||
message.Headers.Authorization = new AuthenticationHeaderValue("Basic", BasicCredentials());
|
||||
using var response = await http.SendAsync(message, ct);
|
||||
response.EnsureSuccessStatusCode();
|
||||
}
|
||||
|
||||
private async Task<TResponse?> PostAsync<TRequest, TResponse>(string path, TRequest body, CancellationToken ct)
|
||||
{
|
||||
using var response = await SendAsync(path, body, ct);
|
||||
@@ -249,14 +154,6 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
|
||||
[property: JsonPropertyName("taskDefinitionKey")] string TaskDefinitionKey,
|
||||
[property: JsonPropertyName("includeProcessVariables")] bool IncludeProcessVariables);
|
||||
|
||||
private sealed record TaskByInstanceQueryRequest(
|
||||
[property: JsonPropertyName("processInstanceId")] string ProcessInstanceId,
|
||||
[property: JsonPropertyName("taskDefinitionKey")] string TaskDefinitionKey);
|
||||
|
||||
private sealed record IdentityLinkRequest(
|
||||
[property: JsonPropertyName("group")] string Group,
|
||||
[property: JsonPropertyName("type")] string Type);
|
||||
|
||||
private sealed record ClaimTaskRequest(
|
||||
[property: JsonPropertyName("action")] string Action,
|
||||
[property: JsonPropertyName("assignee")] string Assignee);
|
||||
@@ -296,10 +193,6 @@ public sealed class FlowableWorkflowClient(HttpClient http, FlowableOptions opti
|
||||
|
||||
private sealed record ExecutionDto([property: JsonPropertyName("id")] string Id);
|
||||
|
||||
private sealed record AcquiredEscalatieJob(
|
||||
[property: JsonPropertyName("id")] string Id,
|
||||
[property: JsonPropertyName("processInstanceId")] string ProcessInstanceId);
|
||||
|
||||
private sealed record AcquiredJob(
|
||||
[property: JsonPropertyName("id")] string Id,
|
||||
[property: JsonPropertyName("variables")] IReadOnlyList<Variable> Variables)
|
||||
|
||||
@@ -16,39 +16,3 @@ public interface IExternalWorkerClient
|
||||
/// <summary>Complete an acquired job, passing the opened zaak URL back into the process.</summary>
|
||||
Task CompleteOpenZaakJobAsync(string jobId, Uri zaakUrl, CancellationToken ct = default);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The escalation side of the Workflow Client (S-14): the <c>BeoordelingEscaleren</c> external-worker
|
||||
/// jobs parked by the 14-day boundary timer on <c>Beoordelen</c>, and the reassignment they drive.
|
||||
/// Kept separate from <see cref="IExternalWorkerClient"/> (interface segregation) so the OpenZaak
|
||||
/// worker never sees escalation. Implemented by <see cref="FlowableWorkflowClient"/> — the only code
|
||||
/// that talks to Flowable (§8.2, ADR-0015).
|
||||
/// </summary>
|
||||
public interface IBeoordelingEscalatieClient
|
||||
{
|
||||
/// <summary>Acquire and lock up to <paramref name="maxJobs"/> <c>BeoordelingEscaleren</c> jobs.</summary>
|
||||
Task<IReadOnlyList<EscalatieJob>> AcquireBeoordelingEscalatieJobsAsync(int maxJobs, CancellationToken ct = default);
|
||||
|
||||
/// <summary>Reassign the still-open <c>Beoordelen</c> task in the given process instance from the
|
||||
/// behandelaar group to teamlead. Best-effort no-op if the task is no longer open.</summary>
|
||||
Task ReassignBeoordelingToTeamleadAsync(string processInstanceId, CancellationToken ct = default);
|
||||
|
||||
/// <summary>Complete an acquired escalation job so its token reaches the escalation end event.</summary>
|
||||
Task CompleteBeoordelingEscalatieJobAsync(string jobId, CancellationToken ct = default);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// The document-timeout side of the Workflow Client (S-10a): the <c>RegistratieVerlopen</c>
|
||||
/// external-worker jobs parked by the 30-day boundary timer on <c>WachtOpDocumenten</c>. Kept separate
|
||||
/// from the other worker ports (interface segregation) so neither the OpenZaak nor escalation worker
|
||||
/// sees expiry. Implemented by <see cref="FlowableWorkflowClient"/> — the only code that talks to
|
||||
/// Flowable (§8.2, ADR-0017).
|
||||
/// </summary>
|
||||
public interface IRegistratieVerlopenClient
|
||||
{
|
||||
/// <summary>Acquire and lock up to <paramref name="maxJobs"/> <c>RegistratieVerlopen</c> jobs.</summary>
|
||||
Task<IReadOnlyList<RegistratieVerlopenJob>> AcquireRegistratieVerlopenJobsAsync(int maxJobs, CancellationToken ct = default);
|
||||
|
||||
/// <summary>Complete an acquired expiry job so its token reaches the <c>endVerlopen</c> end event.</summary>
|
||||
Task CompleteRegistratieVerlopenJobAsync(string jobId, CancellationToken ct = default);
|
||||
}
|
||||
|
||||
@@ -22,8 +22,4 @@ public sealed class InMemoryRegistrationStore : IRegistrationStore
|
||||
|
||||
public Task<Registration?> GetAsync(RegistrationId id, CancellationToken ct = default)
|
||||
=> Task.FromResult(_byId.GetValueOrDefault(id));
|
||||
|
||||
public Task<Registration?> FindOpenByBsnAsync(string bsn, CancellationToken ct = default)
|
||||
=> Task.FromResult(_byId.Values.FirstOrDefault(r =>
|
||||
r.Bsn == bsn && r.Status is RegistrationStatus.Ingediend or RegistrationStatus.InBehandeling));
|
||||
}
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
using Big.Application;
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace Big.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// One poll tick of the document-timeout worker (S-10a, ADR-0017): acquire the parked
|
||||
/// <c>RegistratieVerlopen</c> jobs — the tokens the 30-day boundary timer on <c>WachtOpDocumenten</c>
|
||||
/// spawns — expire each correlated registration via the <see cref="ExpireRegistrationWorker"/>, and
|
||||
/// complete the job so its token reaches <c>endVerlopen</c>. A job that fails is logged and left
|
||||
/// un-completed so Flowable redelivers it (§8.6). Split out from the hosted pump so the
|
||||
/// acquire→expire→complete logic is unit-testable without a running host. Mirrors
|
||||
/// <see cref="OpenZaakJobProcessor"/> and <see cref="BeoordelingEscalatieProcessor"/>.
|
||||
/// </summary>
|
||||
public sealed class RegistratieVerlopenProcessor(
|
||||
IRegistratieVerlopenClient client,
|
||||
ExpireRegistrationWorker worker,
|
||||
ILogger<RegistratieVerlopenProcessor> logger)
|
||||
{
|
||||
/// <summary>Acquire and process up to <paramref name="maxJobs"/> jobs. Returns the number acquired.</summary>
|
||||
public async Task<int> PumpOnceAsync(int maxJobs, CancellationToken ct = default)
|
||||
{
|
||||
var jobs = await client.AcquireRegistratieVerlopenJobsAsync(maxJobs, ct);
|
||||
|
||||
foreach (var job in jobs)
|
||||
{
|
||||
try
|
||||
{
|
||||
await worker.HandleAsync(job, ct);
|
||||
await client.CompleteRegistratieVerlopenJobAsync(job.JobId, ct);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// Leave the job un-completed: its lock expires and Flowable redelivers it (§8.6).
|
||||
logger.LogError(ex, "RegistratieVerlopen job {JobId} failed; leaving it for redelivery.", job.JobId);
|
||||
}
|
||||
}
|
||||
|
||||
return jobs.Count;
|
||||
}
|
||||
}
|
||||
@@ -1,49 +0,0 @@
|
||||
using Microsoft.Extensions.DependencyInjection;
|
||||
using Microsoft.Extensions.Hosting;
|
||||
using Microsoft.Extensions.Logging;
|
||||
|
||||
namespace Big.Infrastructure;
|
||||
|
||||
/// <summary>
|
||||
/// The hosted polling loop of the document-timeout worker (S-10a, ADR-0017): on an interval it
|
||||
/// resolves a scoped <see cref="RegistratieVerlopenProcessor"/> and asks it to drain the parked
|
||||
/// <c>RegistratieVerlopen</c> jobs. A deliberately thin shell — all acquire/expire/complete logic
|
||||
/// lives in the processor, which is unit-tested; this class only owns the timer, the per-tick scope,
|
||||
/// and loop resilience. Structurally identical to <see cref="BeoordelingEscalatiePump"/>.
|
||||
/// </summary>
|
||||
public sealed class RegistratieVerlopenPump(
|
||||
IServiceScopeFactory scopeFactory,
|
||||
FlowableOptions options,
|
||||
ILogger<RegistratieVerlopenPump> logger) : BackgroundService
|
||||
{
|
||||
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
|
||||
{
|
||||
while (!stoppingToken.IsCancellationRequested)
|
||||
{
|
||||
try
|
||||
{
|
||||
using var scope = scopeFactory.CreateScope();
|
||||
var processor = scope.ServiceProvider.GetRequiredService<RegistratieVerlopenProcessor>();
|
||||
await processor.PumpOnceAsync(options.MaxJobsPerPoll, stoppingToken);
|
||||
}
|
||||
catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
|
||||
{
|
||||
break;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
// A transient fault (e.g. Flowable briefly unreachable) must not kill the loop.
|
||||
logger.LogError(ex, "RegistratieVerlopen job poll failed; retrying after the poll interval.");
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
await Task.Delay(options.PollInterval, stoppingToken);
|
||||
}
|
||||
catch (OperationCanceledException) when (stoppingToken.IsCancellationRequested)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
using Big.Application;
|
||||
using Big.Infrastructure;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
|
||||
namespace Big.Tests;
|
||||
|
||||
// S-14 (#15): the escalation drain loop. Mirrors OpenZaakJobProcessor — acquire the parked
|
||||
// BeoordelingEscaleren jobs, reassign each instance's Beoordelen task to teamlead, then complete the
|
||||
// job. A job whose reassignment fails is logged and left un-completed for Flowable to redeliver (§8.6).
|
||||
public class BeoordelingEscalatieProcessorTests
|
||||
{
|
||||
/// <summary>A fake escalation client: scripts the jobs to acquire, records reassignments and
|
||||
/// completions, and can be told to throw on reassigning a given instance.</summary>
|
||||
private sealed class FakeEscalatieClient(params EscalatieJob[] jobs) : IBeoordelingEscalatieClient
|
||||
{
|
||||
public int AcquireCount { get; private set; }
|
||||
public List<string> Reassigned { get; } = [];
|
||||
public List<string> Completed { get; } = [];
|
||||
public string? ThrowOnInstance { get; set; }
|
||||
|
||||
public Task<IReadOnlyList<EscalatieJob>> AcquireBeoordelingEscalatieJobsAsync(int maxJobs, CancellationToken ct = default)
|
||||
{
|
||||
AcquireCount++;
|
||||
return Task.FromResult<IReadOnlyList<EscalatieJob>>(jobs.Take(maxJobs).ToList());
|
||||
}
|
||||
|
||||
public Task ReassignBeoordelingToTeamleadAsync(string processInstanceId, CancellationToken ct = default)
|
||||
{
|
||||
if (processInstanceId == ThrowOnInstance)
|
||||
throw new InvalidOperationException("reassign failed");
|
||||
Reassigned.Add(processInstanceId);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Task CompleteBeoordelingEscalatieJobAsync(string jobId, CancellationToken ct = default)
|
||||
{
|
||||
Completed.Add(jobId);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Acquires_an_escalation_reassigns_to_teamlead_and_completes_the_job()
|
||||
{
|
||||
var client = new FakeEscalatieClient(new EscalatieJob("job-9", "pi-1"));
|
||||
|
||||
var acquired = await new BeoordelingEscalatieProcessor(
|
||||
client, NullLogger<BeoordelingEscalatieProcessor>.Instance).PumpOnceAsync(5);
|
||||
|
||||
Assert.Equal(1, acquired);
|
||||
Assert.Equal("pi-1", Assert.Single(client.Reassigned));
|
||||
Assert.Equal("job-9", Assert.Single(client.Completed));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_failing_reassign_is_left_uncompleted_for_flowable_to_redeliver()
|
||||
{
|
||||
var client = new FakeEscalatieClient(new EscalatieJob("job-9", "pi-1")) { ThrowOnInstance = "pi-1" };
|
||||
var logger = new CapturingLogger<BeoordelingEscalatieProcessor>();
|
||||
|
||||
var acquired = await new BeoordelingEscalatieProcessor(client, logger).PumpOnceAsync(5);
|
||||
|
||||
Assert.Equal(1, acquired);
|
||||
Assert.Empty(client.Completed);
|
||||
var error = Assert.Single(logger.Entries, e => e.Level == LogLevel.Error);
|
||||
Assert.Contains("job-9", error.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Does_nothing_but_poll_when_there_are_no_escalations()
|
||||
{
|
||||
var client = new FakeEscalatieClient();
|
||||
|
||||
var acquired = await new BeoordelingEscalatieProcessor(
|
||||
client, NullLogger<BeoordelingEscalatieProcessor>.Instance).PumpOnceAsync(5);
|
||||
|
||||
Assert.Equal(0, acquired);
|
||||
Assert.Equal(1, client.AcquireCount);
|
||||
Assert.Empty(client.Completed);
|
||||
}
|
||||
}
|
||||
@@ -1,110 +0,0 @@
|
||||
using Big.Application;
|
||||
using Big.Domain;
|
||||
|
||||
namespace Big.Tests;
|
||||
|
||||
// S-10a (#102): the application handler behind the RegistratieVerlopen external-worker job. The 30-day
|
||||
// document-wait timer fired, so the correlated registration is expired to VERLOPEN. Mirrors
|
||||
// OpenZaakWorker — pure application logic over ports, idempotent under at-least-once delivery (§8.6).
|
||||
public class ExpireRegistrationWorkerTests
|
||||
{
|
||||
private const string Bsn = "123456782";
|
||||
|
||||
// By the time the 30-day document timer fires, the zaak was opened long ago (OpenZaakAanmaken runs
|
||||
// early in the flow), so a timed-out registration carries a zaak the worker can cancel.
|
||||
private static Registration Submitted(string processInstanceId = "proc-1", Uri? zaakUrl = null)
|
||||
{
|
||||
var registration = Registration.Submit(Bsn);
|
||||
registration.RecordProcessStarted(processInstanceId);
|
||||
registration.AttachZaak(zaakUrl ?? FakeAclClient.DefaultZaakUrl);
|
||||
return registration;
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Expires_the_registration_the_job_correlates_to()
|
||||
{
|
||||
var store = new FakeRegistrationStore();
|
||||
var registration = Submitted();
|
||||
store.Seed(registration);
|
||||
|
||||
await new ExpireRegistrationWorker(store, new FakeAclClient()).HandleAsync(
|
||||
new RegistratieVerlopenJob("job-7", registration.Id));
|
||||
|
||||
var saved = await store.GetAsync(registration.Id);
|
||||
Assert.Equal(RegistrationStatus.Verlopen, saved!.Status);
|
||||
Assert.Equal(1, store.SaveCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Cancels_the_zaak_via_the_acl_when_expiring_a_still_open_registration()
|
||||
{
|
||||
// S-10c: expiring the aggregate is not enough — the ZGW zaak must also be set to its
|
||||
// cancellation status, which the ACL owns (§8.1). The worker hands the ACL the zaak URL.
|
||||
var store = new FakeRegistrationStore();
|
||||
var zaak = new Uri("http://openzaak/zaken/api/v1/zaken/timed-out");
|
||||
var registration = Submitted(zaakUrl: zaak);
|
||||
store.Seed(registration);
|
||||
var acl = new FakeAclClient();
|
||||
|
||||
await new ExpireRegistrationWorker(store, acl).HandleAsync(
|
||||
new RegistratieVerlopenJob("job-7", registration.Id));
|
||||
|
||||
Assert.Equal(1, acl.CancelCallCount);
|
||||
Assert.Equal(zaak, acl.CancelledZaakUrl);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task An_already_verlopen_registration_is_not_persisted_again_and_the_zaak_is_not_recancelled()
|
||||
{
|
||||
// A redelivered job (§8.6) finds the aggregate already VERLOPEN: a no-op, not saved again — and
|
||||
// the ACL is not asked to cancel the zaak a second time (posting a second resultaat would 400).
|
||||
var store = new FakeRegistrationStore();
|
||||
var registration = Submitted();
|
||||
registration.Expire();
|
||||
store.Seed(registration);
|
||||
var acl = new FakeAclClient();
|
||||
|
||||
await new ExpireRegistrationWorker(store, acl).HandleAsync(
|
||||
new RegistratieVerlopenJob("job-7", registration.Id));
|
||||
|
||||
Assert.Equal(0, store.SaveCount);
|
||||
Assert.Equal(0, acl.CancelCallCount);
|
||||
Assert.Equal(RegistrationStatus.Verlopen, (await store.GetAsync(registration.Id))!.Status);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task An_already_resolved_registration_is_left_alone_and_the_zaak_is_not_cancelled()
|
||||
{
|
||||
// Race with S-11: the citizen withdrew while parked at WachtOpDocumenten, so the aggregate is
|
||||
// already terminal (INGETROKKEN) when the timer's job arrives. Expiring it would violate the
|
||||
// aggregate's invariant; the worker must instead no-op (and let the job complete), not throw
|
||||
// into a redelivery loop — and it must not cancel the zaak of a registration it didn't expire.
|
||||
var store = new FakeRegistrationStore();
|
||||
var registration = Submitted();
|
||||
registration.Withdraw();
|
||||
store.Seed(registration);
|
||||
var acl = new FakeAclClient();
|
||||
|
||||
await new ExpireRegistrationWorker(store, acl).HandleAsync(
|
||||
new RegistratieVerlopenJob("job-7", registration.Id));
|
||||
|
||||
Assert.Equal(0, store.SaveCount);
|
||||
Assert.Equal(0, acl.CancelCallCount);
|
||||
Assert.Equal(RegistrationStatus.Ingetrokken, (await store.GetAsync(registration.Id))!.Status);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task An_unknown_registration_throws_so_the_job_is_redelivered()
|
||||
{
|
||||
var store = new FakeRegistrationStore();
|
||||
|
||||
await Assert.ThrowsAsync<InvalidOperationException>(() =>
|
||||
new ExpireRegistrationWorker(store, new FakeAclClient()).HandleAsync(
|
||||
new RegistratieVerlopenJob("job-7", RegistrationId.New())));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Rejects_a_null_job()
|
||||
=> await Assert.ThrowsAsync<ArgumentNullException>(() =>
|
||||
new ExpireRegistrationWorker(new FakeRegistrationStore(), new FakeAclClient()).HandleAsync(null!));
|
||||
}
|
||||
@@ -22,10 +22,6 @@ internal sealed class FakeRegistrationStore : IRegistrationStore
|
||||
public Task<Registration?> GetAsync(RegistrationId id, CancellationToken ct = default)
|
||||
=> Task.FromResult(_byId.GetValueOrDefault(id));
|
||||
|
||||
public Task<Registration?> FindOpenByBsnAsync(string bsn, CancellationToken ct = default)
|
||||
=> Task.FromResult(_byId.Values.FirstOrDefault(r =>
|
||||
r.Bsn == bsn && r.Status is RegistrationStatus.Ingediend or RegistrationStatus.InBehandeling));
|
||||
|
||||
public void Seed(Registration registration) => _byId[registration.Id] = registration;
|
||||
}
|
||||
|
||||
@@ -36,16 +32,12 @@ internal sealed class FakeWorkflowClient(string processInstanceId = "proc-1", Ac
|
||||
: IWorkflowClient
|
||||
{
|
||||
public RegistrationId? StartedFor { get; private set; }
|
||||
public DiplomaOrigin? StartedWithOrigin { get; private set; }
|
||||
public string? WithdrawnProcessInstanceId { get; private set; }
|
||||
public string? CompletedDocumentWaitFor { get; private set; }
|
||||
|
||||
public Task<string> StartRegistrationProcessAsync(
|
||||
RegistrationId registrationId, DiplomaOrigin diplomaOrigin, CancellationToken ct = default)
|
||||
public Task<string> StartRegistrationProcessAsync(RegistrationId registrationId, CancellationToken ct = default)
|
||||
{
|
||||
onStart?.Invoke(registrationId);
|
||||
StartedFor = registrationId;
|
||||
StartedWithOrigin = diplomaOrigin;
|
||||
return Task.FromResult(processInstanceId);
|
||||
}
|
||||
|
||||
@@ -54,12 +46,6 @@ internal sealed class FakeWorkflowClient(string processInstanceId = "proc-1", Ac
|
||||
WithdrawnProcessInstanceId = processInstanceId;
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Task CompleteDocumentWaitAsync(string processInstanceId, CancellationToken ct = default)
|
||||
{
|
||||
CompletedDocumentWaitFor = processInstanceId;
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>A fake user-task client for the werkbak/decision use cases: returns a scripted set of
|
||||
@@ -114,23 +100,4 @@ internal sealed class FakeAclClient(Uri? zaakUrl = null) : IAclClient
|
||||
ApprovedZaakUrl = zaakUrl;
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public (Uri ZaakUrl, byte[] Content, string FileName, string ContentType)? StoredDiploma { get; private set; }
|
||||
public static readonly Uri DefaultDocumentUrl = new("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/doc");
|
||||
|
||||
public Task<Uri> StoreDiplomaAsync(Uri zaakUrl, byte[] content, string fileName, string contentType, CancellationToken ct = default)
|
||||
{
|
||||
StoredDiploma = (zaakUrl, content, fileName, contentType);
|
||||
return Task.FromResult(DefaultDocumentUrl);
|
||||
}
|
||||
|
||||
public Uri? CancelledZaakUrl { get; private set; }
|
||||
public int CancelCallCount { get; private set; }
|
||||
|
||||
public Task CancelZaakAsync(Uri zaakUrl, CancellationToken ct = default)
|
||||
{
|
||||
CancelCallCount++;
|
||||
CancelledZaakUrl = zaakUrl;
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -24,7 +24,7 @@ public class FlowableWorkflowClientTests
|
||||
var client = Client(capture.Responds(HttpStatusCode.Created, """{"id":"pi-1"}"""));
|
||||
var rid = RegistrationId.New();
|
||||
|
||||
var pid = await client.StartRegistrationProcessAsync(rid, DiplomaOrigin.Binnenlands);
|
||||
var pid = await client.StartRegistrationProcessAsync(rid);
|
||||
|
||||
Assert.Equal("pi-1", pid);
|
||||
Assert.Equal(HttpMethod.Post, capture.Seen!.Method);
|
||||
@@ -38,22 +38,6 @@ public class FlowableWorkflowClientTests
|
||||
Assert.Contains($"\"value\":\"{rid}\"", capture.Body);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(DiplomaOrigin.Binnenlands, "Binnenlands")]
|
||||
[InlineData(DiplomaOrigin.Buitenlands, "Buitenlands")]
|
||||
public async Task Start_posts_the_diploma_origin_as_a_process_variable(DiplomaOrigin origin, string expected)
|
||||
{
|
||||
// The diploma origin rides along as a start variable so the workflow's DMN can route foreign
|
||||
// diplomas through CBGV-advies (S-13, ADR-0016).
|
||||
var capture = new RequestCapture();
|
||||
var client = Client(capture.Responds(HttpStatusCode.Created, """{"id":"pi-1"}"""));
|
||||
|
||||
await client.StartRegistrationProcessAsync(RegistrationId.New(), origin);
|
||||
|
||||
Assert.Contains("\"name\":\"diplomaOrigin\"", capture.Body);
|
||||
Assert.Contains($"\"value\":\"{expected}\"", capture.Body);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Start_uses_the_configured_worker_credentials_and_defaults()
|
||||
{
|
||||
@@ -141,7 +125,7 @@ public class FlowableWorkflowClientTests
|
||||
var client = Client(capture.Responds(HttpStatusCode.InternalServerError));
|
||||
|
||||
await Assert.ThrowsAsync<HttpRequestException>(
|
||||
() => client.StartRegistrationProcessAsync(RegistrationId.New(), DiplomaOrigin.Binnenlands));
|
||||
() => client.StartRegistrationProcessAsync(RegistrationId.New()));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
@@ -151,7 +135,7 @@ public class FlowableWorkflowClientTests
|
||||
var client = Client(capture.Responds(HttpStatusCode.Created, "null"));
|
||||
|
||||
var ex = await Assert.ThrowsAsync<InvalidOperationException>(
|
||||
() => client.StartRegistrationProcessAsync(RegistrationId.New(), DiplomaOrigin.Binnenlands));
|
||||
() => client.StartRegistrationProcessAsync(RegistrationId.New()));
|
||||
Assert.Contains("empty process-instance", ex.Message);
|
||||
}
|
||||
|
||||
@@ -322,210 +306,4 @@ public class FlowableWorkflowClientTests
|
||||
await Assert.ThrowsAsync<HttpRequestException>(
|
||||
() => client.CompleteBeoordelingAsync("task-1", BeoordelingsBesluit.Goedkeuren));
|
||||
}
|
||||
|
||||
// ── S-14 (#15): 14-day beoordeling escalation → reassign to teamlead (ADR-0015) ───────────────
|
||||
// The BPMN parks a parallel escalation token on a non-interrupting P14D boundary timer, surfaced as
|
||||
// an external-worker job on the BeoordelingEscaleren topic. The worker reassigns the still-open
|
||||
// Beoordelen task from the behandelaar group to teamlead, then completes the escalation job.
|
||||
|
||||
[Fact]
|
||||
public async Task Acquire_escalation_jobs_posts_the_escalation_topic_and_parses_the_process_instance()
|
||||
{
|
||||
var capture = new RequestCapture();
|
||||
var client = Client(capture.Responds(HttpStatusCode.OK,
|
||||
"""[{"id":"job-9","processInstanceId":"pi-1"}]"""));
|
||||
|
||||
var jobs = await client.AcquireBeoordelingEscalatieJobsAsync(3);
|
||||
|
||||
var job = Assert.Single(jobs);
|
||||
Assert.Equal("job-9", job.JobId);
|
||||
Assert.Equal("pi-1", job.ProcessInstanceId);
|
||||
Assert.Equal("http://flowable/flowable-rest/external-job-api/acquire/jobs",
|
||||
capture.Seen!.RequestUri!.ToString());
|
||||
Assert.Contains("\"topic\":\"BeoordelingEscaleren\"", capture.Body);
|
||||
Assert.Contains("\"numberOfTasks\":3", capture.Body);
|
||||
Assert.Contains("\"workerId\":\"worker-x\"", capture.Body);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("[]")]
|
||||
[InlineData("null")]
|
||||
public async Task Acquire_escalation_jobs_returns_empty_when_none_are_parked(string body)
|
||||
{
|
||||
var capture = new RequestCapture();
|
||||
var client = Client(capture.Responds(HttpStatusCode.OK, body));
|
||||
|
||||
Assert.Empty(await client.AcquireBeoordelingEscalatieJobsAsync(1));
|
||||
Assert.NotNull(capture.Seen);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Reassign_moves_the_open_beoordelen_task_from_behandelaar_to_teamlead()
|
||||
{
|
||||
var requests = new List<(HttpMethod Method, string Url, string? Body)>();
|
||||
var client = Client(new StubHandler(async req =>
|
||||
{
|
||||
requests.Add((req.Method, req.RequestUri!.ToString(),
|
||||
req.Content is null ? null : await req.Content.ReadAsStringAsync()));
|
||||
// The task query returns the still-open Beoordelen task parked in this instance.
|
||||
return req.RequestUri!.AbsoluteUri.EndsWith("service/query/tasks")
|
||||
? new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = new StringContent("""{"data":[{"id":"task-7"}],"total":1}""",
|
||||
Encoding.UTF8, "application/json"),
|
||||
}
|
||||
: new HttpResponseMessage(HttpStatusCode.OK);
|
||||
}));
|
||||
|
||||
await client.ReassignBeoordelingToTeamleadAsync("pi-1");
|
||||
|
||||
// 1. Find the still-open Beoordelen task in this process instance.
|
||||
var query = requests.Single(r => r.Url.EndsWith("service/query/tasks"));
|
||||
Assert.Equal(HttpMethod.Post, query.Method);
|
||||
Assert.Contains("\"processInstanceId\":\"pi-1\"", query.Body);
|
||||
Assert.Contains("\"taskDefinitionKey\":\"Beoordelen\"", query.Body);
|
||||
// 2. Add teamlead as a candidate group on that task.
|
||||
var add = requests.Single(r => r.Method == HttpMethod.Post
|
||||
&& r.Url.EndsWith("service/runtime/tasks/task-7/identitylinks"));
|
||||
Assert.Contains("\"group\":\"teamlead\"", add.Body);
|
||||
Assert.Contains("\"type\":\"candidate\"", add.Body);
|
||||
// 3. Remove behandelaar as a candidate group — the task now belongs to teamlead.
|
||||
Assert.Contains(requests, r => r.Method == HttpMethod.Delete
|
||||
&& r.Url.EndsWith("service/runtime/tasks/task-7/identitylinks/groups/behandelaar/candidate"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Reassign_is_a_no_op_when_the_beoordelen_task_is_no_longer_open()
|
||||
{
|
||||
// The behandelaar completed it just before the timer fired: nothing to reassign, no throw.
|
||||
var methods = new List<HttpMethod>();
|
||||
var client = Client(new StubHandler(req =>
|
||||
{
|
||||
methods.Add(req.Method);
|
||||
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = new StringContent("""{"data":[],"total":0}""", Encoding.UTF8, "application/json"),
|
||||
});
|
||||
}));
|
||||
|
||||
await client.ReassignBeoordelingToTeamleadAsync("pi-1");
|
||||
|
||||
Assert.DoesNotContain(HttpMethod.Delete, methods);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Complete_escalation_job_posts_to_the_job_complete_endpoint()
|
||||
{
|
||||
var capture = new RequestCapture();
|
||||
var client = Client(capture.Responds(HttpStatusCode.NoContent));
|
||||
|
||||
await client.CompleteBeoordelingEscalatieJobAsync("job-9");
|
||||
|
||||
Assert.Equal(HttpMethod.Post, capture.Seen!.Method);
|
||||
Assert.Equal("http://flowable/flowable-rest/external-job-api/acquire/jobs/job-9/complete",
|
||||
capture.Seen.RequestUri!.ToString());
|
||||
Assert.Contains("\"workerId\":\"worker-x\"", capture.Body);
|
||||
}
|
||||
|
||||
// ── S-10a (#102): document-wait timeout → RegistratieVerlopen (ADR-0017) ──────────────────────
|
||||
// A 30-day interrupting boundary timer on WachtOpDocumenten spawns a RegistratieVerlopen
|
||||
// external-worker job carrying the registration id; the worker expires the registration and
|
||||
// completes the job. Separately, "documents received" completes the WachtOpDocumenten user task.
|
||||
|
||||
[Fact]
|
||||
public async Task Acquire_verlopen_jobs_posts_the_topic_and_parses_jobs_with_their_registration_id()
|
||||
{
|
||||
var rid = RegistrationId.New();
|
||||
var capture = new RequestCapture();
|
||||
var client = Client(capture.Responds(HttpStatusCode.OK,
|
||||
$$"""[{"id":"job-9","variables":[{"name":"registrationId","type":"string","value":"{{rid}}"}]}]"""));
|
||||
|
||||
var jobs = await client.AcquireRegistratieVerlopenJobsAsync(3);
|
||||
|
||||
var job = Assert.Single(jobs);
|
||||
Assert.Equal("job-9", job.JobId);
|
||||
Assert.Equal(rid, job.RegistrationId);
|
||||
Assert.Equal("http://flowable/flowable-rest/external-job-api/acquire/jobs",
|
||||
capture.Seen!.RequestUri!.ToString());
|
||||
Assert.Contains("\"topic\":\"RegistratieVerlopen\"", capture.Body);
|
||||
Assert.Contains("\"numberOfTasks\":3", capture.Body);
|
||||
Assert.Contains("\"workerId\":\"worker-x\"", capture.Body);
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData("[]")]
|
||||
[InlineData("null")]
|
||||
public async Task Acquire_verlopen_jobs_returns_empty_when_none_are_parked(string body)
|
||||
{
|
||||
var capture = new RequestCapture();
|
||||
var client = Client(capture.Responds(HttpStatusCode.OK, body));
|
||||
|
||||
Assert.Empty(await client.AcquireRegistratieVerlopenJobsAsync(1));
|
||||
Assert.NotNull(capture.Seen);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Complete_verlopen_job_posts_to_the_job_complete_endpoint()
|
||||
{
|
||||
var capture = new RequestCapture();
|
||||
var client = Client(capture.Responds(HttpStatusCode.NoContent));
|
||||
|
||||
await client.CompleteRegistratieVerlopenJobAsync("job-9");
|
||||
|
||||
Assert.Equal(HttpMethod.Post, capture.Seen!.Method);
|
||||
Assert.Equal("http://flowable/flowable-rest/external-job-api/acquire/jobs/job-9/complete",
|
||||
capture.Seen.RequestUri!.ToString());
|
||||
Assert.Contains("\"workerId\":\"worker-x\"", capture.Body);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Provide_documents_completes_the_wacht_op_documenten_task_in_the_instance()
|
||||
{
|
||||
var requests = new List<(HttpMethod Method, string Url, string? Body)>();
|
||||
var client = Client(new StubHandler(async req =>
|
||||
{
|
||||
requests.Add((req.Method, req.RequestUri!.ToString(),
|
||||
req.Content is null ? null : await req.Content.ReadAsStringAsync()));
|
||||
return req.RequestUri!.AbsoluteUri.EndsWith("service/query/tasks")
|
||||
? new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = new StringContent("""{"data":[{"id":"task-3"}],"total":1}""",
|
||||
Encoding.UTF8, "application/json"),
|
||||
}
|
||||
: new HttpResponseMessage(HttpStatusCode.OK);
|
||||
}));
|
||||
|
||||
await client.CompleteDocumentWaitAsync("pi-1");
|
||||
|
||||
// 1. Find the still-open WachtOpDocumenten task in this process instance.
|
||||
var query = requests.Single(r => r.Url.EndsWith("service/query/tasks"));
|
||||
Assert.Equal(HttpMethod.Post, query.Method);
|
||||
Assert.Contains("\"processInstanceId\":\"pi-1\"", query.Body);
|
||||
Assert.Contains("\"taskDefinitionKey\":\"WachtOpDocumenten\"", query.Body);
|
||||
// 2. Complete that task so the process leaves the wait state.
|
||||
var complete = requests.Single(r => r.Url.EndsWith("service/runtime/tasks/task-3"));
|
||||
Assert.Equal(HttpMethod.Post, complete.Method);
|
||||
Assert.Contains("\"action\":\"complete\"", complete.Body);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Provide_documents_is_a_no_op_when_the_wait_task_is_no_longer_open()
|
||||
{
|
||||
// The process already left WachtOpDocumenten (e.g. timed out): nothing to complete, no throw.
|
||||
var methods = new List<HttpMethod>();
|
||||
var client = Client(new StubHandler(req =>
|
||||
{
|
||||
methods.Add(req.Method);
|
||||
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
|
||||
{
|
||||
Content = new StringContent("""{"data":[],"total":0}""", Encoding.UTF8, "application/json"),
|
||||
});
|
||||
}));
|
||||
|
||||
await client.CompleteDocumentWaitAsync("pi-1");
|
||||
|
||||
// Only the query ran; no task-completion POST followed.
|
||||
Assert.DoesNotContain(methods, m => m == HttpMethod.Put || m == HttpMethod.Delete);
|
||||
Assert.Single(methods);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -41,59 +41,4 @@ public class InMemoryRegistrationStoreTests
|
||||
|
||||
await Assert.ThrowsAsync<ArgumentNullException>(() => store.SaveAsync(null!));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Finds_the_open_registration_for_a_bsn()
|
||||
{
|
||||
var store = new InMemoryRegistrationStore();
|
||||
var open = Registration.Submit("123456782");
|
||||
await store.SaveAsync(open);
|
||||
|
||||
var found = await store.FindOpenByBsnAsync("123456782");
|
||||
|
||||
Assert.NotNull(found);
|
||||
Assert.Equal(open.Id, found.Id);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task An_in_behandeling_registration_is_still_open()
|
||||
{
|
||||
var store = new InMemoryRegistrationStore();
|
||||
var registration = Registration.Submit("123456782");
|
||||
registration.TakeIntoBehandeling();
|
||||
await store.SaveAsync(registration);
|
||||
|
||||
Assert.NotNull(await store.FindOpenByBsnAsync("123456782"));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(nameof(Registration.Withdraw))]
|
||||
[InlineData(nameof(Registration.Approve))]
|
||||
[InlineData(nameof(Registration.Reject))]
|
||||
[InlineData(nameof(Registration.Expire))]
|
||||
public async Task A_terminal_registration_is_not_returned_as_open(string transition)
|
||||
{
|
||||
var store = new InMemoryRegistrationStore();
|
||||
var registration = Registration.Submit("123456782");
|
||||
registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc")); // Approve requires an opened zaak
|
||||
switch (transition)
|
||||
{
|
||||
case nameof(Registration.Withdraw): registration.Withdraw(); break;
|
||||
case nameof(Registration.Approve): registration.Approve(); break;
|
||||
case nameof(Registration.Reject): registration.Reject(); break;
|
||||
case nameof(Registration.Expire): registration.Expire(); break;
|
||||
}
|
||||
await store.SaveAsync(registration);
|
||||
|
||||
Assert.Null(await store.FindOpenByBsnAsync("123456782"));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Does_not_return_another_bsns_registration_or_an_unknown_bsn()
|
||||
{
|
||||
var store = new InMemoryRegistrationStore();
|
||||
await store.SaveAsync(Registration.Submit("111111110"));
|
||||
|
||||
Assert.Null(await store.FindOpenByBsnAsync("123456782"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,96 +0,0 @@
|
||||
using Big.Application;
|
||||
using Big.Domain;
|
||||
|
||||
namespace Big.Tests;
|
||||
|
||||
// S-10a/S-10b (#102/#103): the "documents received" use case. A zorgprofessional supplies the diploma
|
||||
// their registration is waiting for; the handler stores it in ZGW via the ACL and completes the
|
||||
// WachtOpDocumenten task via the Workflow Client so the process continues to beoordeling. Owner-scoped
|
||||
// by the caller's bsn, like WithdrawRegistration.
|
||||
public class ProvideDocumentsTests
|
||||
{
|
||||
private const string Bsn = "123456782";
|
||||
private static readonly Uri Zaak = new("http://openzaak/zaken/api/v1/zaken/abc");
|
||||
|
||||
private static Registration Submitted(string processInstanceId = "proc-1")
|
||||
{
|
||||
var registration = Registration.Submit(Bsn);
|
||||
registration.RecordProcessStarted(processInstanceId);
|
||||
registration.AttachZaak(Zaak);
|
||||
return registration;
|
||||
}
|
||||
|
||||
private static ProvideDocumentsCommand Command(RegistrationId id, string bsn = Bsn) =>
|
||||
new(id, bsn, [1, 2, 3], "diploma.pdf", "application/pdf");
|
||||
|
||||
[Fact]
|
||||
public async Task Providing_documents_stores_the_diploma_and_completes_the_wait()
|
||||
{
|
||||
var store = new FakeRegistrationStore();
|
||||
var registration = Submitted("proc-42");
|
||||
store.Seed(registration);
|
||||
var workflow = new FakeWorkflowClient();
|
||||
var acl = new FakeAclClient();
|
||||
var handler = new ProvideDocuments(store, workflow, acl);
|
||||
|
||||
var outcome = await handler.HandleAsync(Command(registration.Id));
|
||||
|
||||
Assert.Equal(ProvideDocumentsOutcome.Accepted, outcome);
|
||||
// Stored against the registration's zaak, carrying the uploaded bytes + file metadata.
|
||||
Assert.Equal((Zaak, new byte[] { 1, 2, 3 }, "diploma.pdf", "application/pdf"), acl.StoredDiploma);
|
||||
// …and the wait is completed so beoordeling can proceed.
|
||||
Assert.Equal("proc-42", workflow.CompletedDocumentWaitFor);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_different_bsn_cannot_provide_documents()
|
||||
{
|
||||
// Owner-scoping: another bsn is told NotFound; nothing is stored or completed.
|
||||
var store = new FakeRegistrationStore();
|
||||
var registration = Submitted();
|
||||
store.Seed(registration);
|
||||
var workflow = new FakeWorkflowClient();
|
||||
var acl = new FakeAclClient();
|
||||
var handler = new ProvideDocuments(store, workflow, acl);
|
||||
|
||||
var outcome = await handler.HandleAsync(Command(registration.Id, bsn: "999999990"));
|
||||
|
||||
Assert.Equal(ProvideDocumentsOutcome.NotFound, outcome);
|
||||
Assert.Null(acl.StoredDiploma);
|
||||
Assert.Null(workflow.CompletedDocumentWaitFor);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Providing_for_an_unknown_registration_is_not_found()
|
||||
{
|
||||
var store = new FakeRegistrationStore();
|
||||
var handler = new ProvideDocuments(store, new FakeWorkflowClient(), new FakeAclClient());
|
||||
|
||||
Assert.Equal(ProvideDocumentsOutcome.NotFound, await handler.HandleAsync(Command(RegistrationId.New())));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Providing_before_a_zaak_is_opened_does_not_store_but_still_completes_the_wait()
|
||||
{
|
||||
// No zaak yet → nothing to file the document against, but the request still stands (best-effort,
|
||||
// mirroring WithdrawRegistration). The wait is completed if a process is running.
|
||||
var store = new FakeRegistrationStore();
|
||||
var registration = Registration.Submit(Bsn);
|
||||
registration.RecordProcessStarted("proc-9"); // process started, but no zaak attached
|
||||
store.Seed(registration);
|
||||
var workflow = new FakeWorkflowClient();
|
||||
var acl = new FakeAclClient();
|
||||
var handler = new ProvideDocuments(store, workflow, acl);
|
||||
|
||||
var outcome = await handler.HandleAsync(Command(registration.Id));
|
||||
|
||||
Assert.Equal(ProvideDocumentsOutcome.Accepted, outcome);
|
||||
Assert.Null(acl.StoredDiploma);
|
||||
Assert.Equal("proc-9", workflow.CompletedDocumentWaitFor);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Rejects_a_null_command()
|
||||
=> await Assert.ThrowsAsync<ArgumentNullException>(() =>
|
||||
new ProvideDocuments(new FakeRegistrationStore(), new FakeWorkflowClient(), new FakeAclClient()).HandleAsync(null!));
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
using Big.Application;
|
||||
using Big.Infrastructure;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
|
||||
namespace Big.Tests;
|
||||
|
||||
// S-10a (#102): the document-timeout drain loop. Mirrors BeoordelingEscalatieProcessor — acquire the
|
||||
// parked RegistratieVerlopen jobs (the tokens the 30-day boundary timer on WachtOpDocumenten spawns),
|
||||
// expire each correlated registration via the ExpireRegistrationWorker, then complete the job. A job
|
||||
// whose expiry fails is logged and left un-completed for Flowable to redeliver (§8.6).
|
||||
public class RegistratieVerlopenProcessorTests
|
||||
{
|
||||
/// <summary>A fake client scripting the jobs to acquire and recording completions.</summary>
|
||||
private sealed class FakeVerlopenClient(params RegistratieVerlopenJob[] jobs) : IRegistratieVerlopenClient
|
||||
{
|
||||
public int AcquireCount { get; private set; }
|
||||
public List<string> Completed { get; } = [];
|
||||
|
||||
public Task<IReadOnlyList<RegistratieVerlopenJob>> AcquireRegistratieVerlopenJobsAsync(int maxJobs, CancellationToken ct = default)
|
||||
{
|
||||
AcquireCount++;
|
||||
return Task.FromResult<IReadOnlyList<RegistratieVerlopenJob>>(jobs.Take(maxJobs).ToList());
|
||||
}
|
||||
|
||||
public Task CompleteRegistratieVerlopenJobAsync(string jobId, CancellationToken ct = default)
|
||||
{
|
||||
Completed.Add(jobId);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
|
||||
private static ExpireRegistrationWorker Worker(FakeRegistrationStore store) => new(store, new FakeAclClient());
|
||||
|
||||
[Fact]
|
||||
public async Task Acquires_a_job_expires_the_registration_and_completes_the_job()
|
||||
{
|
||||
var store = new FakeRegistrationStore();
|
||||
var registration = Domain.Registration.Submit("123456782");
|
||||
store.Seed(registration);
|
||||
var client = new FakeVerlopenClient(new RegistratieVerlopenJob("job-9", registration.Id));
|
||||
|
||||
var acquired = await new RegistratieVerlopenProcessor(
|
||||
client, Worker(store), NullLogger<RegistratieVerlopenProcessor>.Instance).PumpOnceAsync(5);
|
||||
|
||||
Assert.Equal(1, acquired);
|
||||
Assert.Equal(Domain.RegistrationStatus.Verlopen, (await store.GetAsync(registration.Id))!.Status);
|
||||
Assert.Equal("job-9", Assert.Single(client.Completed));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task A_failing_expiry_is_left_uncompleted_for_flowable_to_redeliver()
|
||||
{
|
||||
// Unknown registration → the worker throws → the job is left for redelivery, error logged.
|
||||
var store = new FakeRegistrationStore();
|
||||
var client = new FakeVerlopenClient(new RegistratieVerlopenJob("job-9", Domain.RegistrationId.New()));
|
||||
var logger = new CapturingLogger<RegistratieVerlopenProcessor>();
|
||||
|
||||
var acquired = await new RegistratieVerlopenProcessor(client, Worker(store), logger).PumpOnceAsync(5);
|
||||
|
||||
Assert.Equal(1, acquired);
|
||||
Assert.Empty(client.Completed);
|
||||
var error = Assert.Single(logger.Entries, e => e.Level == LogLevel.Error);
|
||||
Assert.Contains("job-9", error.Message);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Does_nothing_but_poll_when_there_are_no_jobs()
|
||||
{
|
||||
var client = new FakeVerlopenClient();
|
||||
|
||||
var acquired = await new RegistratieVerlopenProcessor(
|
||||
client, Worker(new FakeRegistrationStore()), NullLogger<RegistratieVerlopenProcessor>.Instance).PumpOnceAsync(5);
|
||||
|
||||
Assert.Equal(0, acquired);
|
||||
Assert.Equal(1, client.AcquireCount);
|
||||
Assert.Empty(client.Completed);
|
||||
}
|
||||
}
|
||||
@@ -16,15 +16,6 @@ public class RegistrationTests
|
||||
Assert.Null(registration.ProcessInstanceId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void A_registration_defaults_to_a_domestic_diploma()
|
||||
=> Assert.Equal(DiplomaOrigin.Binnenlands, Registration.Submit("123456782").DiplomaOrigin);
|
||||
|
||||
[Fact]
|
||||
public void A_foreign_diploma_submission_records_its_origin()
|
||||
=> Assert.Equal(DiplomaOrigin.Buitenlands,
|
||||
Registration.Submit("123456782", DiplomaOrigin.Buitenlands).DiplomaOrigin);
|
||||
|
||||
[Theory]
|
||||
[InlineData("")]
|
||||
[InlineData(" ")]
|
||||
@@ -294,63 +285,4 @@ public class RegistrationTests
|
||||
Assert.Contains("only an INGEDIEND", ex.Message);
|
||||
Assert.Equal(RegistrationStatus.Afgewezen, registration.Status);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Expiring_an_ingediend_registration_sets_it_verlopen()
|
||||
{
|
||||
// The 30-day document-wait timer fired before the documents arrived (S-10a): the case is
|
||||
// cancelled and the aggregate becomes terminal VERLOPEN.
|
||||
var registration = Registration.Submit("123456782");
|
||||
|
||||
registration.Expire();
|
||||
|
||||
Assert.Equal(RegistrationStatus.Verlopen, registration.Status);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Expiring_needs_no_zaak()
|
||||
{
|
||||
// The timer fires on a purely time-based boundary; expiry does not depend on the zaak.
|
||||
var registration = Registration.Submit("123456782");
|
||||
|
||||
registration.Expire();
|
||||
|
||||
Assert.Equal(RegistrationStatus.Verlopen, registration.Status);
|
||||
Assert.Null(registration.ZaakUrl);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Re_expiring_an_already_verlopen_registration_is_idempotent()
|
||||
{
|
||||
// The RegistratieVerlopen worker job may be redelivered (§8.6); re-expiring is a no-op.
|
||||
var registration = Registration.Submit("123456782");
|
||||
registration.Expire();
|
||||
|
||||
registration.Expire();
|
||||
|
||||
Assert.Equal(RegistrationStatus.Verlopen, registration.Status);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Expiring_an_approved_registration_is_rejected()
|
||||
{
|
||||
var registration = Registration.Submit("123456782");
|
||||
registration.AttachZaak(new Uri("http://openzaak/zaken/api/v1/zaken/abc"));
|
||||
registration.Approve();
|
||||
|
||||
var ex = Assert.Throws<InvalidOperationException>(() => registration.Expire());
|
||||
Assert.Contains("only an INGEDIEND", ex.Message);
|
||||
Assert.Equal(RegistrationStatus.Ingeschreven, registration.Status);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Expiring_a_withdrawn_registration_is_rejected()
|
||||
{
|
||||
var registration = Registration.Submit("123456782");
|
||||
registration.Withdraw();
|
||||
|
||||
var ex = Assert.Throws<InvalidOperationException>(() => registration.Expire());
|
||||
Assert.Contains("only an INGEDIEND", ex.Message);
|
||||
Assert.Equal(RegistrationStatus.Ingetrokken, registration.Status);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -25,19 +25,6 @@ public class SubmitRegistrationTests
|
||||
Assert.Equal(2, store.SaveCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Submitting_a_foreign_diploma_carries_its_origin_to_the_process()
|
||||
{
|
||||
var store = new FakeRegistrationStore();
|
||||
var workflow = new FakeWorkflowClient();
|
||||
var handler = new SubmitRegistration(store, workflow);
|
||||
|
||||
var id = await handler.HandleAsync(new SubmitRegistrationCommand("123456782", DiplomaOrigin.Buitenlands));
|
||||
|
||||
Assert.Equal(DiplomaOrigin.Buitenlands, (await store.GetAsync(id))!.DiplomaOrigin);
|
||||
Assert.Equal(DiplomaOrigin.Buitenlands, workflow.StartedWithOrigin);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public async Task Rejects_a_null_command_without_touching_the_store_or_workflow()
|
||||
{
|
||||
|
||||
@@ -4,9 +4,7 @@
|
||||
"test-projects": ["Big.Tests/Big.Tests.csproj"],
|
||||
"reporters": ["progress", "html"],
|
||||
"mutate": [
|
||||
"!**/OpenZaakJobPump.cs",
|
||||
"!**/BeoordelingEscalatiePump.cs",
|
||||
"!**/RegistratieVerlopenPump.cs"
|
||||
"!**/OpenZaakJobPump.cs"
|
||||
],
|
||||
"thresholds": {
|
||||
"high": 95,
|
||||
|
||||
@@ -22,9 +22,6 @@
|
||||
<ProjectReference Include="..\..\services\acl\Acl.Infrastructure\Acl.Infrastructure.csproj" />
|
||||
<ProjectReference Include="..\..\services\event-subscriber\EventSubscriber.Application\EventSubscriber.Application.csproj" />
|
||||
<ProjectReference Include="..\..\services\domain\Big.Application\Big.Application.csproj" />
|
||||
<!-- The beoordeling-escalation scenario drives the escalation worker (Infrastructure), as the
|
||||
ACL scenario drives Acl.Infrastructure — escalation has no domain-aggregate surface (S-14). -->
|
||||
<ProjectReference Include="..\..\services\domain\Big.Infrastructure\Big.Infrastructure.csproj" />
|
||||
<ProjectReference Include="..\..\services\bff\Bff.Api\Bff.Api.csproj" />
|
||||
</ItemGroup>
|
||||
|
||||
|
||||
@@ -1,22 +0,0 @@
|
||||
# language: en
|
||||
# Drives S-14 (#15). A beoordeling a behandelaar does not pick up within 14 days escalates to the
|
||||
# teamlead: a non-interrupting boundary timer parks a BeoordelingEscaleren job (ADR-0015) which the
|
||||
# escalation worker drains, reassigning the still-open Beoordelen task's candidate group to teamlead.
|
||||
# A beoordeling completed before the timer fires does not escalate. This scenario exercises the
|
||||
# escalation worker against an in-memory Flowable stand-in; the timer firing live is verify-domain.
|
||||
Feature: Een beoordeling escaleren
|
||||
Als teamleider wil ik dat een beoordeling die na 14 dagen niet is opgepakt naar mij escaleert
|
||||
zodat aanvragen niet blijven liggen.
|
||||
|
||||
Scenario: Na 14 dagen zonder oppakken escaleert de beoordeling naar de teamlead
|
||||
Given a registration parked at the Beoordelen task for the behandelaar
|
||||
When the 14-day escalation timer fires
|
||||
And the escalation worker runs
|
||||
Then the beoordeling is reassigned to the teamlead
|
||||
|
||||
Scenario: Een tijdig afgeronde beoordeling escaleert niet
|
||||
Given a registration parked at the Beoordelen task for the behandelaar
|
||||
When the behandelaar completes the beoordeling before the timer fires
|
||||
And the 14-day escalation timer fires
|
||||
And the escalation worker runs
|
||||
Then the beoordeling stays with the behandelaar
|
||||
@@ -1,19 +0,0 @@
|
||||
# language: en
|
||||
# Drives S-13 (#14). A registration's diploma origin decides its route: a domestic (Binnenlands)
|
||||
# diploma goes straight to beoordeling, a foreign (Buitenlands) one is routed through an extra
|
||||
# CBGV-advies step (PRD flow 4). The decision itself is a DMN evaluated inside the workflow
|
||||
# (ADR-0016); the domain's part — verified here — is carrying the origin into the process so the DMN
|
||||
# can route on it. The DMN evaluation and the CBGV routing are verified live (verify-domain).
|
||||
Feature: Een diploma op herkomst routeren
|
||||
Als register wil ik een aanvraag met een buitenlands diploma extra laten toetsen
|
||||
zodat een CBGV-advies wordt ingewonnen voordat een behandelaar beoordeelt.
|
||||
|
||||
Scenario: Een binnenlands diploma start de registratie als binnenlands
|
||||
Given a zorgprofessional with a "Binnenlands" diploma
|
||||
When they submit their registration
|
||||
Then the registratie process is started carrying a "Binnenlands" diploma
|
||||
|
||||
Scenario: Een buitenlands diploma start de registratie als buitenlands
|
||||
Given a zorgprofessional with a "Buitenlands" diploma
|
||||
When they submit their registration
|
||||
Then the registratie process is started carrying a "Buitenlands" diploma
|
||||
@@ -1,25 +0,0 @@
|
||||
# language: en
|
||||
# Drives S-10a (#102). After the zaak is opened the process parks at WachtOpDocumenten with an
|
||||
# INTERRUPTING 30-day boundary timer. If the documents do not arrive in time the timer cancels the
|
||||
# task and parks a RegistratieVerlopen job (ADR-0017) which the timeout worker drains, expiring the
|
||||
# registration to VERLOPEN. Documents received before the timer fires close the wait, so no expiry
|
||||
# happens. This scenario exercises the timeout worker against an in-memory Flowable stand-in; the timer
|
||||
# firing live is verify-domain.
|
||||
Feature: Een documenttermijn laten verlopen
|
||||
Als registerbeheerder wil ik dat een aanvraag waarvoor de documenten niet binnen 30 dagen binnen zijn
|
||||
automatisch vervalt zodat onvolledige aanvragen niet blijven liggen.
|
||||
|
||||
Scenario: Zonder documenten binnen 30 dagen vervalt de registratie
|
||||
Given a registration parked at the WachtOpDocumenten task
|
||||
When the 30-day document timer fires
|
||||
And the document-timeout worker runs
|
||||
Then the registration is verlopen
|
||||
And the zaak is cancelled in ZGW
|
||||
|
||||
Scenario: Tijdig aangeleverde documenten laten de registratie niet vervallen
|
||||
Given a registration parked at the WachtOpDocumenten task
|
||||
When the documents arrive before the timer fires
|
||||
And the 30-day document timer fires
|
||||
And the document-timeout worker runs
|
||||
Then the registration is not verlopen
|
||||
And the zaak is not cancelled in ZGW
|
||||
@@ -1,44 +0,0 @@
|
||||
using Acceptance.Support;
|
||||
using Big.Infrastructure;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using Reqnroll;
|
||||
using Xunit;
|
||||
|
||||
namespace Acceptance.Steps;
|
||||
|
||||
/// <summary>Bindings for <c>EenBeoordelingEscaleren.feature</c> (S-14). Drives the escalation worker
|
||||
/// (<see cref="BeoordelingEscalatieProcessor"/>) against an in-memory Flowable stand-in; one instance
|
||||
/// per scenario. Escalation has no domain-aggregate surface — it only reassigns who may claim the
|
||||
/// still-open Beoordelen task — so the scenario asserts on the task's candidate group.</summary>
|
||||
[Binding]
|
||||
[Scope(Feature = "Een beoordeling escaleren")]
|
||||
public sealed class EenBeoordelingEscalerenSteps
|
||||
{
|
||||
private readonly InMemoryEscalatieClient _flowable = new();
|
||||
private string _processInstanceId = "";
|
||||
|
||||
[Given("a registration parked at the Beoordelen task for the behandelaar")]
|
||||
public void GivenARegistrationParkedForTheBehandelaar()
|
||||
=> _processInstanceId = _flowable.ParkBeoordeling();
|
||||
|
||||
[When("the 14-day escalation timer fires")]
|
||||
public void WhenTheEscalationTimerFires()
|
||||
=> _flowable.FireEscalationTimer(_processInstanceId);
|
||||
|
||||
[When("the behandelaar completes the beoordeling before the timer fires")]
|
||||
public void WhenTheBehandelaarCompletesBeforeTheTimer()
|
||||
=> _flowable.CompleteBeoordeling(_processInstanceId);
|
||||
|
||||
[When("the escalation worker runs")]
|
||||
public async Task WhenTheEscalationWorkerRuns()
|
||||
=> await new BeoordelingEscalatieProcessor(
|
||||
_flowable, NullLogger<BeoordelingEscalatieProcessor>.Instance).PumpOnceAsync(5);
|
||||
|
||||
[Then("the beoordeling is reassigned to the teamlead")]
|
||||
public void ThenTheBeoordelingIsReassignedToTheTeamlead()
|
||||
=> Assert.Equal("teamlead", _flowable.CandidateGroupFor(_processInstanceId));
|
||||
|
||||
[Then("the beoordeling stays with the behandelaar")]
|
||||
public void ThenTheBeoordelingStaysWithTheBehandelaar()
|
||||
=> Assert.Equal("behandelaar", _flowable.CandidateGroupFor(_processInstanceId));
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
using Acceptance.Support;
|
||||
using Big.Application;
|
||||
using Big.Domain;
|
||||
using Reqnroll;
|
||||
using Xunit;
|
||||
|
||||
namespace Acceptance.Steps;
|
||||
|
||||
/// <summary>Bindings for <c>EenDiplomaRouteren.feature</c> (S-13). Drives the submit use case against
|
||||
/// in-memory ports and asserts the registratie process is started carrying the diploma origin — the
|
||||
/// domain's contribution to flow 4. The DMN evaluation and the foreign→CBGV-advies routing it drives
|
||||
/// are verified live (verify-domain); one instance per scenario.</summary>
|
||||
[Binding]
|
||||
[Scope(Feature = "Een diploma op herkomst routeren")]
|
||||
public sealed class EenDiplomaRouterenSteps
|
||||
{
|
||||
private readonly InMemoryRegistrationStore _store = new();
|
||||
private readonly InMemoryWorkflowClient _workflow = new();
|
||||
private DiplomaOrigin _origin;
|
||||
|
||||
[Given("a zorgprofessional with a \"(.*)\" diploma")]
|
||||
public void GivenAZorgprofessionalWithADiploma(string origin)
|
||||
=> _origin = Enum.Parse<DiplomaOrigin>(origin, ignoreCase: true);
|
||||
|
||||
[When("they submit their registration")]
|
||||
public async Task WhenTheySubmitTheirRegistration()
|
||||
=> await new SubmitRegistration(_store, _workflow).HandleAsync(
|
||||
new SubmitRegistrationCommand("123456782", _origin));
|
||||
|
||||
[Then("the registratie process is started carrying a \"(.*)\" diploma")]
|
||||
public void ThenTheProcessIsStartedCarryingTheDiploma(string expected)
|
||||
{
|
||||
Assert.NotNull(_workflow.StartedFor);
|
||||
Assert.Equal(Enum.Parse<DiplomaOrigin>(expected, ignoreCase: true), _workflow.StartedWithOrigin);
|
||||
}
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
using Acceptance.Support;
|
||||
using Big.Application;
|
||||
using Big.Domain;
|
||||
using Big.Infrastructure;
|
||||
using Microsoft.Extensions.Logging.Abstractions;
|
||||
using Reqnroll;
|
||||
using Xunit;
|
||||
|
||||
namespace Acceptance.Steps;
|
||||
|
||||
/// <summary>Bindings for <c>EenDocumentTermijnVerlopen.feature</c> (S-10a). Drives the timeout worker
|
||||
/// (<see cref="RegistratieVerlopenProcessor"/> over the <see cref="ExpireRegistrationWorker"/>) against
|
||||
/// an in-memory Flowable stand-in and a shared registration store; one instance per scenario. The
|
||||
/// interrupting 30-day timer either cancels the wait and expires the registration, or — if the
|
||||
/// documents arrived first — never fires; the scenario asserts on the aggregate's status.</summary>
|
||||
[Binding]
|
||||
[Scope(Feature = "Een documenttermijn laten verlopen")]
|
||||
public sealed class EenDocumentTermijnVerlopenSteps
|
||||
{
|
||||
private static readonly Uri ZaakUrl = new("http://openzaak/zaken/api/v1/zaken/acc-timeout");
|
||||
|
||||
private readonly InMemoryDocumentTimeoutClient _flowable = new();
|
||||
private readonly Support.InMemoryRegistrationStore _store = new();
|
||||
private readonly InMemoryAclClient _acl = new();
|
||||
private Registration _registration = null!;
|
||||
private string _processInstanceId = "";
|
||||
|
||||
[Given("a registration parked at the WachtOpDocumenten task")]
|
||||
public async Task GivenARegistrationParkedAtWachtOpDocumenten()
|
||||
{
|
||||
_registration = Registration.Submit("123456782");
|
||||
// By the time it parks at WachtOpDocumenten its zaak has been opened (OpenZaakAanmaken runs
|
||||
// earlier), so a timeout has a zaak to cancel.
|
||||
_registration.AttachZaak(ZaakUrl);
|
||||
await _store.SaveAsync(_registration);
|
||||
_processInstanceId = _flowable.ParkWaitingForDocuments(_registration.Id);
|
||||
}
|
||||
|
||||
[When("the 30-day document timer fires")]
|
||||
public void WhenTheDocumentTimerFires() => _flowable.FireDocumentTimer(_processInstanceId);
|
||||
|
||||
[When("the documents arrive before the timer fires")]
|
||||
public void WhenTheDocumentsArriveBeforeTheTimer() => _flowable.ReceiveDocuments(_processInstanceId);
|
||||
|
||||
[When("the document-timeout worker runs")]
|
||||
public async Task WhenTheTimeoutWorkerRuns()
|
||||
=> await new RegistratieVerlopenProcessor(
|
||||
_flowable, new ExpireRegistrationWorker(_store, _acl),
|
||||
NullLogger<RegistratieVerlopenProcessor>.Instance).PumpOnceAsync(5);
|
||||
|
||||
[Then("the registration is verlopen")]
|
||||
public async Task ThenTheRegistrationIsVerlopen()
|
||||
=> Assert.Equal(RegistrationStatus.Verlopen, (await _store.GetAsync(_registration.Id))!.Status);
|
||||
|
||||
[Then("the registration is not verlopen")]
|
||||
public async Task ThenTheRegistrationIsNotVerlopen()
|
||||
=> Assert.Equal(RegistrationStatus.Ingediend, (await _store.GetAsync(_registration.Id))!.Status);
|
||||
|
||||
[Then("the zaak is cancelled in ZGW")]
|
||||
public void ThenTheZaakIsCancelled() => Assert.Equal(ZaakUrl, _acl.CancelledZaakUrl);
|
||||
|
||||
[Then("the zaak is not cancelled in ZGW")]
|
||||
public void ThenTheZaakIsNotCancelled() => Assert.Null(_acl.CancelledZaakUrl);
|
||||
}
|
||||
@@ -29,12 +29,8 @@ public sealed class EenZaakOpenenSteps
|
||||
Bronorganisatie = values["bronorganisatie"],
|
||||
VerantwoordelijkeOrganisatie = values["verantwoordelijkeOrganisatie"],
|
||||
Vertrouwelijkheidaanduiding = values["vertrouwelijkheidaanduiding"],
|
||||
ZaaktypeIdentificatie = "BIG-REGISTRATIE",
|
||||
InformatieobjecttypeOmschrijving = "Diploma",
|
||||
ZaaktypeUrl = new Uri(values["zaaktype"]),
|
||||
};
|
||||
// The ACL resolves the zaaktype by identificatie (S-27); the scenario's zaaktype URL is what
|
||||
// the catalogus resolves it to, so the created zaak still carries that URL.
|
||||
_gateway.ResolvedZaaktypeUrl = new Uri(values["zaaktype"]);
|
||||
}
|
||||
|
||||
[Given("today is \"(.*)\"")]
|
||||
@@ -44,7 +40,7 @@ public sealed class EenZaakOpenenSteps
|
||||
[When("the domain asks the ACL to open a zaak")]
|
||||
public async Task WhenTheDomainAsksTheAclToOpenAZaak()
|
||||
{
|
||||
var service = new AclService(_gateway, _defaults!, new CachedZaaktypeCatalog(_gateway, _defaults!), new FixedClock(_today));
|
||||
var service = new AclService(_gateway, _defaults!, new FixedClock(_today));
|
||||
_returnedUrl = await service.OpenZaakAsync(_registration!);
|
||||
}
|
||||
|
||||
|
||||
@@ -69,16 +69,9 @@ public sealed class CapturingDomainClient : IDomainClient
|
||||
return Task.FromResult(new SubmitAccepted("reg-acc-1", "Ingediend"));
|
||||
}
|
||||
|
||||
public Task<CurrentRegistration?> GetCurrentRegistrationAsync(string bsn, CancellationToken ct = default)
|
||||
=> Task.FromResult<CurrentRegistration?>(null);
|
||||
|
||||
public Task<bool> WithdrawRegistrationAsync(string registrationId, string bsn, CancellationToken ct = default)
|
||||
=> Task.FromResult(true);
|
||||
|
||||
public Task<bool> ProvideDocumentsAsync(
|
||||
string registrationId, string bsn, string contentBase64, string? fileName, string? contentType, CancellationToken ct = default)
|
||||
=> Task.FromResult(true);
|
||||
|
||||
public Task<IReadOnlyList<WerkbakItem>> GetWerkbakAsync(CancellationToken ct = default)
|
||||
=> Task.FromResult<IReadOnlyList<WerkbakItem>>([]);
|
||||
|
||||
|
||||
@@ -1,6 +1,5 @@
|
||||
using Big.Application;
|
||||
using Big.Domain;
|
||||
using Big.Infrastructure;
|
||||
|
||||
namespace Acceptance.Support;
|
||||
|
||||
@@ -12,15 +11,11 @@ public sealed class InMemoryWorkflowClient : IWorkflowClient
|
||||
public const string StartedProcessInstanceId = "proc-acc-1";
|
||||
|
||||
public RegistrationId? StartedFor { get; private set; }
|
||||
public DiplomaOrigin? StartedWithOrigin { get; private set; }
|
||||
public string? WithdrawnProcessInstanceId { get; private set; }
|
||||
public string? CompletedDocumentWaitFor { get; private set; }
|
||||
|
||||
public Task<string> StartRegistrationProcessAsync(
|
||||
RegistrationId registrationId, DiplomaOrigin diplomaOrigin, CancellationToken ct = default)
|
||||
public Task<string> StartRegistrationProcessAsync(RegistrationId registrationId, CancellationToken ct = default)
|
||||
{
|
||||
StartedFor = registrationId;
|
||||
StartedWithOrigin = diplomaOrigin;
|
||||
return Task.FromResult(StartedProcessInstanceId);
|
||||
}
|
||||
|
||||
@@ -29,12 +24,6 @@ public sealed class InMemoryWorkflowClient : IWorkflowClient
|
||||
WithdrawnProcessInstanceId = processInstanceId;
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Task CompleteDocumentWaitAsync(string processInstanceId, CancellationToken ct = default)
|
||||
{
|
||||
CompletedDocumentWaitFor = processInstanceId;
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>An in-memory ACL stand-in: records the bsn it opened a zaak for and returns a fixed URL,
|
||||
@@ -59,22 +48,6 @@ public sealed class InMemoryAclClient : IAclClient
|
||||
ApprovedZaakUrl = zaakUrl;
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Uri? CancelledZaakUrl { get; private set; }
|
||||
|
||||
public Task CancelZaakAsync(Uri zaakUrl, CancellationToken ct = default)
|
||||
{
|
||||
CancelledZaakUrl = zaakUrl;
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public (Uri ZaakUrl, string FileName)? StoredDiploma { get; private set; }
|
||||
|
||||
public Task<Uri> StoreDiplomaAsync(Uri zaakUrl, byte[] content, string fileName, string contentType, CancellationToken ct = default)
|
||||
{
|
||||
StoredDiploma = (zaakUrl, fileName);
|
||||
return Task.FromResult(new Uri("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/acc-doc"));
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>An in-memory user-task client for the beoordeling acceptance scenario: it holds one open
|
||||
@@ -100,110 +73,6 @@ public sealed class InMemoryUserTaskClient : IUserTaskClient
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>An in-memory Flowable stand-in for the beoordeling-escalation scenario (S-14): it models
|
||||
/// one Beoordelen task per process instance — its candidate group and whether it is still open — and
|
||||
/// the escalation jobs the non-interrupting 14-day boundary timer parks. It drives the escalation
|
||||
/// worker's behaviour without a running Flowable; the timer firing live is the verify-domain check.</summary>
|
||||
public sealed class InMemoryEscalatieClient : IBeoordelingEscalatieClient
|
||||
{
|
||||
private sealed class ParkedTask
|
||||
{
|
||||
public string CandidateGroup { get; set; } = "behandelaar";
|
||||
public bool IsOpen { get; set; } = true;
|
||||
}
|
||||
|
||||
private readonly Dictionary<string, ParkedTask> _tasks = [];
|
||||
private readonly List<EscalatieJob> _parked = [];
|
||||
private int _seq;
|
||||
|
||||
/// <summary>A registration parks at Beoordelen, claimable by the behandelaar group.</summary>
|
||||
public string ParkBeoordeling()
|
||||
{
|
||||
var pid = $"pi-{++_seq}";
|
||||
_tasks[pid] = new ParkedTask();
|
||||
return pid;
|
||||
}
|
||||
|
||||
/// <summary>The behandelaar completes the beoordeling before the timer fires: the task closes.</summary>
|
||||
public void CompleteBeoordeling(string processInstanceId) => _tasks[processInstanceId].IsOpen = false;
|
||||
|
||||
/// <summary>The 14-day boundary timer fires: a non-interrupting token parks an escalation job.</summary>
|
||||
public void FireEscalationTimer(string processInstanceId)
|
||||
=> _parked.Add(new EscalatieJob($"job-{++_seq}", processInstanceId));
|
||||
|
||||
/// <summary>The candidate group that may currently pick the task up.</summary>
|
||||
public string CandidateGroupFor(string processInstanceId) => _tasks[processInstanceId].CandidateGroup;
|
||||
|
||||
public Task<IReadOnlyList<EscalatieJob>> AcquireBeoordelingEscalatieJobsAsync(int maxJobs, CancellationToken ct = default)
|
||||
=> Task.FromResult<IReadOnlyList<EscalatieJob>>(_parked.Take(maxJobs).ToList());
|
||||
|
||||
public Task ReassignBeoordelingToTeamleadAsync(string processInstanceId, CancellationToken ct = default)
|
||||
{
|
||||
// No-op if the behandelaar already completed it — the timer/completion race (§8.6).
|
||||
var task = _tasks[processInstanceId];
|
||||
if (task.IsOpen)
|
||||
task.CandidateGroup = "teamlead";
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Task CompleteBeoordelingEscalatieJobAsync(string jobId, CancellationToken ct = default)
|
||||
{
|
||||
_parked.RemoveAll(j => j.JobId == jobId);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>An in-memory Flowable stand-in for the document-timeout scenario (S-10a): it models one
|
||||
/// WachtOpDocumenten wait per process instance — whether it is still open and the registration it
|
||||
/// correlates to — and the RegistratieVerlopen jobs the interrupting 30-day boundary timer parks. It
|
||||
/// drives the timeout worker's behaviour without a running Flowable; the timer firing live is the
|
||||
/// verify-domain check.</summary>
|
||||
public sealed class InMemoryDocumentTimeoutClient : IRegistratieVerlopenClient
|
||||
{
|
||||
private sealed class Wait
|
||||
{
|
||||
public required RegistrationId RegistrationId { get; init; }
|
||||
public bool IsWaiting { get; set; } = true;
|
||||
}
|
||||
|
||||
private readonly Dictionary<string, Wait> _waits = [];
|
||||
private readonly List<RegistratieVerlopenJob> _parked = [];
|
||||
private int _seq;
|
||||
|
||||
/// <summary>A registration parks at WachtOpDocumenten, waiting for the citizen's documents.</summary>
|
||||
public string ParkWaitingForDocuments(RegistrationId registrationId)
|
||||
{
|
||||
var pid = $"pi-{++_seq}";
|
||||
_waits[pid] = new Wait { RegistrationId = registrationId };
|
||||
return pid;
|
||||
}
|
||||
|
||||
/// <summary>The documents arrive before the timer fires: the wait task closes, so the interrupting
|
||||
/// timer no longer fires (mirrors the Workflow Client completing WachtOpDocumenten).</summary>
|
||||
public void ReceiveDocuments(string processInstanceId) => _waits[processInstanceId].IsWaiting = false;
|
||||
|
||||
/// <summary>The 30-day interrupting boundary timer fires: if still waiting, it cancels the wait and
|
||||
/// parks a RegistratieVerlopen job carrying the correlated registration id. A no-op if the documents
|
||||
/// already arrived (the wait/timer race, §8.6).</summary>
|
||||
public void FireDocumentTimer(string processInstanceId)
|
||||
{
|
||||
var wait = _waits[processInstanceId];
|
||||
if (!wait.IsWaiting)
|
||||
return;
|
||||
wait.IsWaiting = false;
|
||||
_parked.Add(new RegistratieVerlopenJob($"job-{++_seq}", wait.RegistrationId));
|
||||
}
|
||||
|
||||
public Task<IReadOnlyList<RegistratieVerlopenJob>> AcquireRegistratieVerlopenJobsAsync(int maxJobs, CancellationToken ct = default)
|
||||
=> Task.FromResult<IReadOnlyList<RegistratieVerlopenJob>>(_parked.Take(maxJobs).ToList());
|
||||
|
||||
public Task CompleteRegistratieVerlopenJobAsync(string jobId, CancellationToken ct = default)
|
||||
{
|
||||
_parked.RemoveAll(j => j.JobId == jobId);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>An in-memory registration store for the domain acceptance scenario.</summary>
|
||||
public sealed class InMemoryRegistrationStore : IRegistrationStore
|
||||
{
|
||||
@@ -217,8 +86,4 @@ public sealed class InMemoryRegistrationStore : IRegistrationStore
|
||||
|
||||
public Task<Registration?> GetAsync(RegistrationId id, CancellationToken ct = default)
|
||||
=> Task.FromResult(_byId.GetValueOrDefault(id));
|
||||
|
||||
public Task<Registration?> FindOpenByBsnAsync(string bsn, CancellationToken ct = default)
|
||||
=> Task.FromResult(_byId.Values.FirstOrDefault(r =>
|
||||
r.Bsn == bsn && r.Status is RegistrationStatus.Ingediend or RegistrationStatus.InBehandeling));
|
||||
}
|
||||
|
||||
@@ -12,12 +12,6 @@ public sealed class InMemoryZaakGateway : IZaakGateway
|
||||
|
||||
public ZaakRequest? Captured { get; private set; }
|
||||
public (Uri Zaak, Uri Zaaktype, DateOnly Datum)? Approved { get; private set; }
|
||||
public (Uri Zaak, Uri Zaaktype, DateOnly Datum)? Cancelled { get; private set; }
|
||||
|
||||
// The URLs the catalogus resolves the configured identificatie/omschrijving to (S-27); settable so
|
||||
// a scenario can pin the zaaktype the ACL should default-fill.
|
||||
public Uri ResolvedZaaktypeUrl { get; set; } = new("http://openzaak/catalogi/api/v1/zaaktypen/big");
|
||||
public Uri ResolvedInformatieobjecttypeUrl { get; set; } = new("http://openzaak/catalogi/api/v1/informatieobjecttypen/dip");
|
||||
|
||||
public Task<Uri> OpenZaakAsync(ZaakRequest request, CancellationToken ct = default)
|
||||
{
|
||||
@@ -31,21 +25,6 @@ public sealed class InMemoryZaakGateway : IZaakGateway
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Task SetZaakToCancellationStatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default)
|
||||
{
|
||||
Cancelled = (zaakUrl, zaaktypeUrl, datumStatusGezet);
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
public Task<string> GetZaakIdentificatieAsync(Uri zaakUrl, CancellationToken ct = default)
|
||||
=> Task.FromResult("ACC-REF-1");
|
||||
|
||||
public Task<Uri> StoreDocumentAsync(DocumentRequest request, CancellationToken ct = default)
|
||||
=> Task.FromResult(new Uri("http://openzaak/documenten/api/v1/enkelvoudiginformatieobjecten/acc-doc"));
|
||||
|
||||
public Task<Uri> ResolveZaaktypeUrlAsync(string identificatie, CancellationToken ct = default)
|
||||
=> Task.FromResult(ResolvedZaaktypeUrl);
|
||||
|
||||
public Task<Uri> ResolveInformatieobjecttypeUrlAsync(string omschrijving, CancellationToken ct = default)
|
||||
=> Task.FromResult(ResolvedInformatieobjecttypeUrl);
|
||||
}
|
||||
|
||||
@@ -12,12 +12,6 @@ export default defineConfig({
|
||||
timeout: 90_000,
|
||||
expect: { timeout: 15_000 },
|
||||
retries: 1,
|
||||
// Run the specs serially. Each spec drives a full `channel: 'chromium'` browser, and the e2e
|
||||
// shares an 8 GB runner with the entire compose stack (OpenZaak, NRC, Keycloak, Flowable, 4×
|
||||
// Postgres, every service + 3 portals). Two parallel browsers exhaust memory and the renderer is
|
||||
// OOM-killed mid-action ("Page crashed") — fixing the flakiness at its source rather than leaning
|
||||
// on `retries` (CLAUDE.md §15). Only two long-running happy-path specs, so serial costs little.
|
||||
workers: 1,
|
||||
reporter: [['list']],
|
||||
use: {
|
||||
baseURL,
|
||||
@@ -32,13 +26,7 @@ export default defineConfig({
|
||||
// headless), not Playwright's default headless-shell, so pin `channel: 'chromium'`.
|
||||
channel: 'chromium',
|
||||
launchOptions: {
|
||||
args: [
|
||||
`--unsafely-treat-insecure-origin-as-secure=${baseURL},${behandelURL}`,
|
||||
// Write Chromium's shared memory to /tmp instead of the container's small /dev/shm, so a
|
||||
// large DOM/heap can't crash the renderer on the memory-constrained runner (belt-and-braces
|
||||
// alongside the single worker above).
|
||||
'--disable-dev-shm-usage',
|
||||
],
|
||||
args: [`--unsafely-treat-insecure-origin-as-secure=${baseURL},${behandelURL}`],
|
||||
},
|
||||
},
|
||||
projects: [{ name: 'chromium', use: { ...devices['Desktop Chrome'] } }],
|
||||
|
||||
@@ -1,23 +1,16 @@
|
||||
import { expect, test } from '@playwright/test';
|
||||
|
||||
// Walking-skeleton happy path (S-08d + S-09 + S-09b + S-12 + S-10a): a zorgprofessional logs in via
|
||||
// mock DigiD and submits through the self-service portal → BFF → domain; the entry appears in the
|
||||
// openbaar register as INGEDIEND; the citizen supplies the documents the process is waiting for
|
||||
// (S-10a); a behandelaar then logs in to the behandel portal, finds the registration in the werkbak,
|
||||
// and approves it (goedkeuren); the decision completes the Flowable Beoordelen task and flows via the
|
||||
// ACL → NRC → event-subscriber → projection, and the openbaar register shows INGESCHREVEN.
|
||||
test('DigiD submit → public INGEDIEND → documenten → behandelaar goedkeurt → public INGESCHREVEN', async ({
|
||||
page,
|
||||
context,
|
||||
}) => {
|
||||
// Walking-skeleton happy path (S-08d + S-09 + S-09b + S-12): a zorgprofessional logs in via mock
|
||||
// DigiD and submits through the self-service portal → BFF → domain; the entry appears in the openbaar
|
||||
// register as INGEDIEND; a behandelaar then logs in to the behandel portal, finds the registration in
|
||||
// the werkbak, and approves it (goedkeuren); the decision completes the Flowable Beoordelen task and
|
||||
// flows via the ACL → NRC → event-subscriber → projection, and the openbaar register shows INGESCHREVEN.
|
||||
test('DigiD submit → public INGEDIEND → behandelaar goedkeurt → public INGESCHREVEN', async ({ page }) => {
|
||||
// Visiting the guarded page redirects to the Keycloak (mock DigiD) login.
|
||||
await page.goto('/');
|
||||
|
||||
// Keycloak's default login form (stable ids across themes). Its own DigiD user: the verify-* API
|
||||
// checks submit as jan-burger (bsn 123456782) before the e2e runs on the shared stack, and
|
||||
// resume-on-load (S-26) would otherwise restore one of those on login — so each self-service spec
|
||||
// uses a dedicated citizen no other actor touches.
|
||||
await page.locator('#username').fill('emma-burger');
|
||||
// Keycloak's default login form (stable ids across themes).
|
||||
await page.locator('#username').fill('jan-burger');
|
||||
await page.locator('#password').fill('test123');
|
||||
await page.locator('#kc-login').click();
|
||||
|
||||
@@ -33,58 +26,42 @@ test('DigiD submit → public INGEDIEND → documenten → behandelaar goedkeurt
|
||||
expect(reference, 'the confirmation shows a registration reference').toBeTruthy();
|
||||
|
||||
// The openbaar register (anonymous, its own origin) shows the submitted entry once the projection
|
||||
// catches up. We check it on a SEPARATE page so the self-service tab keeps its (in-memory) submitted
|
||||
// state — the "Documenten aanleveren" action below acts on that same session. The projection updates
|
||||
// asynchronously (NRC → event-subscriber), so reload until *this* submission's row appears. We poll
|
||||
// on the reference cell (not a generic INGEDIEND cell): the shared verify stack already holds
|
||||
// INGEDIEND rows from earlier checks, so a status-only poll would short-circuit on a stale row.
|
||||
const staff = await context.newPage();
|
||||
await staff.goto('http://openbaar/');
|
||||
await expect(staff.getByRole('heading', { name: /Openbaar BIG-register/i })).toBeVisible();
|
||||
// catches up. The projection updates asynchronously (NRC → event-subscriber), and the register loads
|
||||
// on open, so reload until *this* submission's row appears. We poll on the reference cell (not a
|
||||
// generic INGEDIEND cell): the shared verify stack already holds INGEDIEND rows from earlier checks,
|
||||
// so a status-only poll would short-circuit on a stale row before our row is projected.
|
||||
await page.goto('http://openbaar/');
|
||||
await expect(page.getByRole('heading', { name: /Openbaar BIG-register/i })).toBeVisible();
|
||||
|
||||
// #78: the reference shown in the public register must be the exact one the citizen saw on the
|
||||
// submit confirmation — no mismatch between the two portals.
|
||||
await expect
|
||||
.poll(async () => {
|
||||
await staff.reload();
|
||||
return staff.getByRole('cell', { name: reference }).count();
|
||||
await page.reload();
|
||||
return page.getByRole('cell', { name: reference }).count();
|
||||
}, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
|
||||
.toBeGreaterThan(0);
|
||||
await expect(staff.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGEDIEND' }))
|
||||
await expect(page.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGEDIEND' }))
|
||||
.toBeVisible();
|
||||
|
||||
// Provide the documents the registration is waiting for (S-10a), on the still-open self-service tab.
|
||||
// The process parks at WachtOpDocumenten only after the zaak is opened; the INGEDIEND row above proves
|
||||
// the zaak exists — so the OpenZaak worker has completed and the process is now at the wait — which is
|
||||
// why we supply the documents here rather than right after submit, when the trigger would race the
|
||||
// wait and no-op. (S-10b turns this into a real file upload; here it is the trigger that unblocks
|
||||
// beoordeling.)
|
||||
await page.setInputFiles('#diploma', {
|
||||
name: 'diploma.pdf',
|
||||
mimeType: 'application/pdf',
|
||||
buffer: Buffer.from('%PDF-1.4 synthetic diploma\n'),
|
||||
});
|
||||
await page.getByRole('button', { name: /documenten aanleveren/i }).click();
|
||||
await expect(page.getByText(/documenten zijn aangeleverd/i)).toBeVisible();
|
||||
// A behandelaar picks the registration up in the behandel-portal werkbak and approves it
|
||||
// (goedkeuren) — the S-12 flow that replaces the temporary admin endpoint. Navigating here switches
|
||||
// to the medewerker realm (a different Keycloak realm than the citizen's digid session).
|
||||
await page.goto('http://behandel/');
|
||||
await page.locator('#username').fill('merel-behandelaar');
|
||||
await page.locator('#password').fill('test123');
|
||||
await page.locator('#kc-login').click();
|
||||
|
||||
// A behandelaar picks the registration up in the behandel-portal werkbak and approves it (goedkeuren)
|
||||
// — the S-12 flow that replaces the temporary admin endpoint. The staff tab switches to the
|
||||
// medewerker realm (a different Keycloak realm than the citizen's digid session).
|
||||
await staff.goto('http://behandel/');
|
||||
await staff.locator('#username').fill('merel-behandelaar');
|
||||
await staff.locator('#password').fill('test123');
|
||||
await staff.locator('#kc-login').click();
|
||||
await expect(page.getByRole('heading', { name: /Werkbak/i })).toBeVisible();
|
||||
|
||||
await expect(staff.getByRole('heading', { name: /Werkbak/i })).toBeVisible();
|
||||
|
||||
// The registration reaches the Beoordelen user task only after its documents are provided (above), so
|
||||
// The registration parks at the Beoordelen user task only after the worker has opened its zaak, so
|
||||
// it appears in the werkbak asynchronously — reload until this reference's row shows up. Target the
|
||||
// decide button by reference (not a generic "Goedkeuren"): the shared verify stack holds other open
|
||||
// tasks, so a positional match could act on someone else's registration.
|
||||
const goedkeuren = staff.getByRole('button', { name: `Goedkeuren ${reference}` });
|
||||
const goedkeuren = page.getByRole('button', { name: `Goedkeuren ${reference}` });
|
||||
await expect
|
||||
.poll(async () => {
|
||||
await staff.reload();
|
||||
await page.reload();
|
||||
return goedkeuren.count();
|
||||
}, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
|
||||
.toBeGreaterThan(0);
|
||||
@@ -92,7 +69,7 @@ test('DigiD submit → public INGEDIEND → documenten → behandelaar goedkeurt
|
||||
// Click and wait for the decide POST to finish (204) BEFORE leaving the page. `click()` only
|
||||
// dispatches the request; navigating away immediately cancels it in flight (nginx logs a 499) and
|
||||
// the decision never reaches the domain — so the registration would stay INGEDIEND.
|
||||
const decided = staff.waitForResponse(
|
||||
const decided = page.waitForResponse(
|
||||
(r) =>
|
||||
r.url().includes(`/behandel/registrations/${reference}/decide`) &&
|
||||
r.request().method() === 'POST',
|
||||
@@ -102,11 +79,11 @@ test('DigiD submit → public INGEDIEND → documenten → behandelaar goedkeurt
|
||||
|
||||
// The approval flows back to the projection; back on the openbaar register *our* row (matched by
|
||||
// its reference) now shows INGESCHREVEN.
|
||||
await staff.goto('http://openbaar/');
|
||||
await page.goto('http://openbaar/');
|
||||
await expect
|
||||
.poll(async () => {
|
||||
await staff.reload();
|
||||
return staff.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGESCHREVEN' }).count();
|
||||
await page.reload();
|
||||
return page.getByRole('row', { name: reference }).getByRole('cell', { name: 'INGESCHREVEN' }).count();
|
||||
}, { timeout: 30_000, intervals: [1_000, 2_000, 3_000, 5_000] })
|
||||
.toBeGreaterThan(0);
|
||||
});
|
||||
|
||||
@@ -1,33 +0,0 @@
|
||||
import { expect, test } from '@playwright/test';
|
||||
|
||||
// S-26: a zorgprofessional submits, then reloads the self-service portal. On load the portal asks the
|
||||
// BFF for the caller's current open registration (owner-scoped by the DigiD token's bsn) and restores
|
||||
// the submitted view — so a refresh no longer strands the in-flight registration and its actions.
|
||||
test('DigiD submit → reload → self-service restores the existing registration', async ({ page }) => {
|
||||
await page.goto('/');
|
||||
|
||||
// Its own DigiD user (like every self-service spec): on the shared verify stack, resume-on-load
|
||||
// (S-26) restores any open registration for the bsn, so each spec uses a dedicated citizen that no
|
||||
// other spec or verify-* check touches. This one in particular leaves an open registration.
|
||||
await page.locator('#username').fill('sanne-burger');
|
||||
await page.locator('#password').fill('test123');
|
||||
await page.locator('#kc-login').click();
|
||||
|
||||
await expect(page.getByRole('heading', { name: /Zelfservice/i })).toBeVisible();
|
||||
await page.getByRole('button', { name: /indienen/i }).click();
|
||||
|
||||
const confirmation = page.getByText(/ontvangen/i);
|
||||
await expect(confirmation).toBeVisible();
|
||||
const reference = (await confirmation.textContent())?.match(/Referentie:\s*([0-9a-fA-F-]+)/)?.[1];
|
||||
expect(reference, 'the confirmation shows a registration reference').toBeTruthy();
|
||||
|
||||
// Reload: the component's in-memory submitted state is gone, but the DigiD session persists and the
|
||||
// portal resumes from the BFF instead of dropping back to the blank submit form.
|
||||
await page.reload();
|
||||
|
||||
await expect(page.getByText(/ontvangen/i)).toBeVisible();
|
||||
// The same reference the citizen saw before the reload is restored...
|
||||
await expect(page.getByText(new RegExp(reference!))).toBeVisible();
|
||||
// ...and its actions are reachable again (e.g. "trek aanvraag in").
|
||||
await expect(page.getByRole('button', { name: /trek aanvraag in/i })).toBeVisible();
|
||||
});
|
||||
@@ -8,9 +8,7 @@ test('DigiD submit → trek aanvraag in → self-service confirms ingetrokken',
|
||||
// Visiting the guarded page redirects to the Keycloak (mock DigiD) login.
|
||||
await page.goto('/');
|
||||
|
||||
// Its own DigiD user — isolated from the verify-* checks (jan-burger/123456782) so resume-on-load
|
||||
// (S-26) can't restore someone else's registration on the shared stack.
|
||||
await page.locator('#username').fill('lars-burger');
|
||||
await page.locator('#username').fill('jan-burger');
|
||||
await page.locator('#password').fill('test123');
|
||||
await page.locator('#kc-login').click();
|
||||
|
||||
|
||||
@@ -1,41 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<definitions xmlns="https://www.omg.org/spec/DMN/20191111/MODEL/"
|
||||
xmlns:flowable="http://flowable.org/dmn"
|
||||
id="diplomaEligibilityDefinitions"
|
||||
name="Diploma eligibility"
|
||||
namespace="http://respellion.nl/big/dmn">
|
||||
<!-- Diploma-eligibility decision (S-13, ADR-0016). Evaluated inline by the registratie process as a
|
||||
BPMN DMN service task: given the diploma's origin, it sets the `route` the process should take.
|
||||
A foreign (Buitenlands) diploma routes through the extra CBGV-advies assessment step; a domestic
|
||||
one (or anything else) goes DIRECT to beoordeling. FIRST hit policy: the foreign rule wins, and
|
||||
the empty-input catch-all is the default.
|
||||
NB: the comment lives INSIDE <definitions> on purpose — Flowable's DMN XML converter chokes on a
|
||||
comment between the XML declaration and the root element ("XMLStreamReader not in START_DOCUMENT
|
||||
or START_ELEMENT state"), unlike its BPMN converter. -->
|
||||
<decision id="diploma-eligibility" name="Diploma eligibility">
|
||||
<decisionTable id="dt-diploma-eligibility" hitPolicy="FIRST">
|
||||
<input id="in-origin" label="Diploma origin">
|
||||
<inputExpression id="ie-origin" typeRef="string">
|
||||
<text>diplomaOrigin</text>
|
||||
</inputExpression>
|
||||
</input>
|
||||
<output id="out-route" label="Route" name="route" typeRef="string"/>
|
||||
<rule id="rule-foreign">
|
||||
<inputEntry id="rule-foreign-in">
|
||||
<text>"Buitenlands"</text>
|
||||
</inputEntry>
|
||||
<outputEntry id="rule-foreign-out">
|
||||
<text>"CBGV_ADVIES"</text>
|
||||
</outputEntry>
|
||||
</rule>
|
||||
<rule id="rule-default">
|
||||
<inputEntry id="rule-default-in">
|
||||
<text></text>
|
||||
</inputEntry>
|
||||
<outputEntry id="rule-default-out">
|
||||
<text>"DIRECT"</text>
|
||||
</outputEntry>
|
||||
</rule>
|
||||
</decisionTable>
|
||||
</decision>
|
||||
</definitions>
|
||||
+18
-176
@@ -1,7 +1,6 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL"
|
||||
xmlns:flowable="http://flowable.org/bpmn"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
|
||||
xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI"
|
||||
xmlns:omgdc="http://www.omg.org/spec/DD/20100524/DC"
|
||||
xmlns:omgdi="http://www.omg.org/spec/DD/20100524/DI"
|
||||
@@ -16,22 +15,7 @@
|
||||
S-11 adds withdrawal: while parked at Beoordelen the citizen can trek de aanvraag in — an
|
||||
interrupting message boundary event (RegistratieIngetrokken) cancels the task and ends the
|
||||
process via a dedicated "ingetrokken" end (ADR-0014). The Workflow Client delivers the message
|
||||
to the task's execution; the BPMN owns the cancellation path.
|
||||
S-14 adds escalation: a NON-interrupting boundary timer (P14D) on Beoordelen. If a behandelaar
|
||||
has not picked the task up within 14 days it fires a parallel token to an external-worker task
|
||||
(BeoordelingEscaleren); the Workflow Client reassigns the still-open Beoordelen task from the
|
||||
behandelaar group to teamlead (ADR-0015). The Beoordelen task stays open throughout — the timer
|
||||
only changes who may claim it.
|
||||
S-13 adds diploma-eligibility routing: between the document wait and Beoordelen a DMN service
|
||||
task (flowable:type="dmn") evaluates the `diploma-eligibility` decision on the diplomaOrigin
|
||||
start variable; an exclusive gateway routes a foreign diploma through the CBGV-advies user task
|
||||
before Beoordelen, a domestic one straight there (ADR-0016).
|
||||
S-10a adds the document wait: right after the zaak is opened the process parks at a
|
||||
WachtOpDocumenten user task with an INTERRUPTING P30D boundary timer. "Documents received"
|
||||
(the S-10b upload, via the Workflow Client) completes the task and the process continues to the
|
||||
diploma routing; if the 30 days lapse first the timer cancels the task and runs the
|
||||
RegistratieVerlopen external-worker task, whose worker expires the registration to VERLOPEN,
|
||||
ending the process as "verlopen" (ADR-0017). -->
|
||||
to the task's execution; the BPMN owns the cancellation path. -->
|
||||
<message id="Message_Ingetrokken" name="RegistratieIngetrokken"/>
|
||||
|
||||
<process id="registratie" name="Registratie ontvangen" isExecutable="true">
|
||||
@@ -44,62 +28,7 @@
|
||||
flowable:type="external-worker"
|
||||
flowable:topic="OpenZaakAanmaken"/>
|
||||
|
||||
<sequenceFlow id="flow2" sourceRef="OpenZaakAanmaken" targetRef="WachtOpDocumenten"/>
|
||||
|
||||
<!-- S-10a: wait for the citizen's documents (diploma). The process parks here; "documents received"
|
||||
(the S-10b upload path) completes the task via the Workflow Client. An INTERRUPTING P30D
|
||||
boundary timer cancels the case if the documents never arrive (ADR-0017). -->
|
||||
<userTask id="WachtOpDocumenten" name="Wacht op documenten"/>
|
||||
|
||||
<sequenceFlow id="flow2doc" sourceRef="WachtOpDocumenten" targetRef="DiplomaEligibiliteit"/>
|
||||
|
||||
<boundaryEvent id="DocumentenTimer" attachedToRef="WachtOpDocumenten" cancelActivity="true">
|
||||
<timerEventDefinition>
|
||||
<timeDuration>P30D</timeDuration>
|
||||
</timerEventDefinition>
|
||||
</boundaryEvent>
|
||||
|
||||
<sequenceFlow id="flow7" sourceRef="DocumentenTimer" targetRef="RegistratieVerlopen"/>
|
||||
|
||||
<!-- On timeout: an external-worker task the Workflow Client picks up to expire the registration to
|
||||
VERLOPEN (S-10a). Its topic mirrors OpenZaakAanmaken/BeoordelingEscaleren. -->
|
||||
<serviceTask id="RegistratieVerlopen" name="Registratie laten verlopen"
|
||||
flowable:type="external-worker"
|
||||
flowable:topic="RegistratieVerlopen"/>
|
||||
|
||||
<sequenceFlow id="flow8" sourceRef="RegistratieVerlopen" targetRef="endVerlopen"/>
|
||||
|
||||
<endEvent id="endVerlopen" name="Registratie verlopen"/>
|
||||
|
||||
<!-- S-13: evaluate the diploma-eligibility DMN inline (ADR-0016). A Flowable DMN service task
|
||||
(flowable:type="dmn" — NOT a businessRuleTask, whose default implementation is the legacy
|
||||
Drools/KIE one that flowable-rest does not bundle) runs the deployed `diploma-eligibility`
|
||||
decision against the diplomaOrigin start variable and sets the `route` output as a process
|
||||
variable. The gateway then routes a foreign diploma through CBGV-advies, a domestic one
|
||||
straight to Beoordelen. -->
|
||||
<serviceTask id="DiplomaEligibiliteit" name="Diploma-eligibiliteit bepalen" flowable:type="dmn">
|
||||
<extensionElements>
|
||||
<flowable:field name="decisionTableReferenceKey">
|
||||
<flowable:string><![CDATA[diploma-eligibility]]></flowable:string>
|
||||
</flowable:field>
|
||||
</extensionElements>
|
||||
</serviceTask>
|
||||
|
||||
<sequenceFlow id="flow2a" sourceRef="DiplomaEligibiliteit" targetRef="RouteOpDiploma"/>
|
||||
|
||||
<exclusiveGateway id="RouteOpDiploma" name="Buitenlands diploma?" default="flowDirect"/>
|
||||
|
||||
<sequenceFlow id="flowCbgv" sourceRef="RouteOpDiploma" targetRef="CBGVAdvies">
|
||||
<conditionExpression xsi:type="tFormalExpression"><![CDATA[${route == 'CBGV_ADVIES'}]]></conditionExpression>
|
||||
</sequenceFlow>
|
||||
|
||||
<!-- The extra CBGV-style assessment for foreign diplomas (PRD flow 4). A CBGV medewerker
|
||||
completes it, after which the case continues to the regular beoordeling. -->
|
||||
<userTask id="CBGVAdvies" name="CBGV-advies" flowable:candidateGroups="cbgv"/>
|
||||
|
||||
<sequenceFlow id="flowCbgvNaarBeoordelen" sourceRef="CBGVAdvies" targetRef="Beoordelen"/>
|
||||
|
||||
<sequenceFlow id="flowDirect" sourceRef="RouteOpDiploma" targetRef="Beoordelen"/>
|
||||
<sequenceFlow id="flow2" sourceRef="OpenZaakAanmaken" targetRef="Beoordelen"/>
|
||||
|
||||
<userTask id="Beoordelen" name="Beoordelen" flowable:candidateGroups="behandelaar"/>
|
||||
|
||||
@@ -116,25 +45,6 @@
|
||||
<sequenceFlow id="flow4" sourceRef="Ingetrokken" targetRef="endIngetrokken"/>
|
||||
|
||||
<endEvent id="endIngetrokken" name="Registratie ingetrokken"/>
|
||||
|
||||
<!-- Escalation (S-14): non-interrupting P14D boundary timer on Beoordelen. On timeout a parallel
|
||||
token runs EscaleerBeoordeling, an external-worker task the Workflow Client picks up to
|
||||
reassign the still-open Beoordelen task from behandelaar to teamlead (ADR-0015). -->
|
||||
<boundaryEvent id="EscaleerTimer" attachedToRef="Beoordelen" cancelActivity="false">
|
||||
<timerEventDefinition>
|
||||
<timeDuration>P14D</timeDuration>
|
||||
</timerEventDefinition>
|
||||
</boundaryEvent>
|
||||
|
||||
<sequenceFlow id="flow5" sourceRef="EscaleerTimer" targetRef="EscaleerBeoordeling"/>
|
||||
|
||||
<serviceTask id="EscaleerBeoordeling" name="Beoordeling escaleren"
|
||||
flowable:type="external-worker"
|
||||
flowable:topic="BeoordelingEscaleren"/>
|
||||
|
||||
<sequenceFlow id="flow6" sourceRef="EscaleerBeoordeling" targetRef="endEscaleren"/>
|
||||
|
||||
<endEvent id="endEscaleren" name="Beoordeling geëscaleerd"/>
|
||||
</process>
|
||||
|
||||
<bpmndi:BPMNDiagram id="diagram">
|
||||
@@ -143,103 +53,35 @@
|
||||
<omgdc:Bounds x="100" y="100" width="30" height="30"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_task" bpmnElement="OpenZaakAanmaken">
|
||||
<omgdc:Bounds x="180" y="85" width="120" height="60"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_wacht" bpmnElement="WachtOpDocumenten">
|
||||
<omgdc:Bounds x="340" y="85" width="120" height="60"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_documentenTimer" bpmnElement="DocumentenTimer">
|
||||
<omgdc:Bounds x="385" y="130" width="30" height="30"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_verlopen" bpmnElement="RegistratieVerlopen">
|
||||
<omgdc:Bounds x="340" y="220" width="120" height="60"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_endVerlopen" bpmnElement="endVerlopen">
|
||||
<omgdc:Bounds x="510" y="235" width="30" height="30"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_dmn" bpmnElement="DiplomaEligibiliteit">
|
||||
<omgdc:Bounds x="510" y="85" width="120" height="60"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_route" bpmnElement="RouteOpDiploma" isMarkerVisible="true">
|
||||
<omgdc:Bounds x="680" y="90" width="40" height="40"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_cbgv" bpmnElement="CBGVAdvies">
|
||||
<omgdc:Bounds x="660" y="200" width="120" height="60"/>
|
||||
<omgdc:Bounds x="200" y="85" width="120" height="60"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_beoordelen" bpmnElement="Beoordelen">
|
||||
<omgdc:Bounds x="790" y="85" width="120" height="60"/>
|
||||
<omgdc:Bounds x="390" y="85" width="120" height="60"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_end" bpmnElement="end">
|
||||
<omgdc:Bounds x="970" y="100" width="30" height="30"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_ingetrokken" bpmnElement="Ingetrokken">
|
||||
<omgdc:Bounds x="850" y="135" width="30" height="30"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_endIngetrokken" bpmnElement="endIngetrokken">
|
||||
<omgdc:Bounds x="850" y="250" width="30" height="30"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_escaleerTimer" bpmnElement="EscaleerTimer">
|
||||
<omgdc:Bounds x="860" y="70" width="30" height="30"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_escaleerBeoordeling" bpmnElement="EscaleerBeoordeling">
|
||||
<omgdc:Bounds x="960" y="20" width="120" height="60"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_endEscaleren" bpmnElement="endEscaleren">
|
||||
<omgdc:Bounds x="1130" y="35" width="30" height="30"/>
|
||||
<omgdc:Bounds x="580" y="100" width="30" height="30"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNEdge id="e_flow1" bpmnElement="flow1">
|
||||
<omgdi:waypoint x="130" y="115"/>
|
||||
<omgdi:waypoint x="180" y="115"/>
|
||||
<omgdi:waypoint x="200" y="115"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flow2" bpmnElement="flow2">
|
||||
<omgdi:waypoint x="300" y="115"/>
|
||||
<omgdi:waypoint x="340" y="115"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flow2doc" bpmnElement="flow2doc">
|
||||
<omgdi:waypoint x="460" y="115"/>
|
||||
<omgdi:waypoint x="510" y="115"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flow7" bpmnElement="flow7">
|
||||
<omgdi:waypoint x="400" y="160"/>
|
||||
<omgdi:waypoint x="400" y="220"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flow8" bpmnElement="flow8">
|
||||
<omgdi:waypoint x="460" y="250"/>
|
||||
<omgdi:waypoint x="510" y="250"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flow2a" bpmnElement="flow2a">
|
||||
<omgdi:waypoint x="630" y="115"/>
|
||||
<omgdi:waypoint x="680" y="110"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flowDirect" bpmnElement="flowDirect">
|
||||
<omgdi:waypoint x="720" y="110"/>
|
||||
<omgdi:waypoint x="790" y="115"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flowCbgv" bpmnElement="flowCbgv">
|
||||
<omgdi:waypoint x="700" y="130"/>
|
||||
<omgdi:waypoint x="700" y="200"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flowCbgvNaarBeoordelen" bpmnElement="flowCbgvNaarBeoordelen">
|
||||
<omgdi:waypoint x="780" y="230"/>
|
||||
<omgdi:waypoint x="820" y="230"/>
|
||||
<omgdi:waypoint x="820" y="145"/>
|
||||
<omgdi:waypoint x="320" y="115"/>
|
||||
<omgdi:waypoint x="390" y="115"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flow3" bpmnElement="flow3">
|
||||
<omgdi:waypoint x="910" y="115"/>
|
||||
<omgdi:waypoint x="970" y="115"/>
|
||||
<omgdi:waypoint x="510" y="115"/>
|
||||
<omgdi:waypoint x="580" y="115"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNShape id="s_ingetrokken" bpmnElement="Ingetrokken">
|
||||
<omgdc:Bounds x="435" y="135" width="30" height="30"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNShape id="s_endIngetrokken" bpmnElement="endIngetrokken">
|
||||
<omgdc:Bounds x="435" y="220" width="30" height="30"/>
|
||||
</bpmndi:BPMNShape>
|
||||
<bpmndi:BPMNEdge id="e_flow4" bpmnElement="flow4">
|
||||
<omgdi:waypoint x="865" y="165"/>
|
||||
<omgdi:waypoint x="865" y="250"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flow5" bpmnElement="flow5">
|
||||
<omgdi:waypoint x="875" y="70"/>
|
||||
<omgdi:waypoint x="875" y="50"/>
|
||||
<omgdi:waypoint x="960" y="50"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
<bpmndi:BPMNEdge id="e_flow6" bpmnElement="flow6">
|
||||
<omgdi:waypoint x="1080" y="50"/>
|
||||
<omgdi:waypoint x="1130" y="50"/>
|
||||
<omgdi:waypoint x="450" y="165"/>
|
||||
<omgdi:waypoint x="450" y="220"/>
|
||||
</bpmndi:BPMNEdge>
|
||||
</bpmndi:BPMNPlane>
|
||||
</bpmndi:BPMNDiagram>
|
||||
|
||||
Reference in New Issue
Block a user