362 lines
19 KiB
C#
362 lines
19 KiB
C#
using System.Net.Http.Headers;
|
|
using System.Net.Http.Json;
|
|
using System.Text.Json.Serialization;
|
|
using Acl.Application;
|
|
|
|
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);
|
|
|
|
using var message = new HttpRequestMessage(
|
|
HttpMethod.Post, new Uri(options.BaseUrl, "/zaken/api/v1/zaken"))
|
|
{
|
|
Content = JsonContent.Create(new ZaakDto(
|
|
request.Bronorganisatie,
|
|
request.Zaaktype.ToString(),
|
|
request.VerantwoordelijkeOrganisatie,
|
|
request.Startdatum.ToString("yyyy-MM-dd"),
|
|
request.Vertrouwelijkheidaanduiding,
|
|
request.Identificatie)),
|
|
};
|
|
message.Headers.Authorization =
|
|
new AuthenticationHeaderValue("Bearer", ZgwToken.Mint(options.ClientId, options.Secret));
|
|
// ZRC is a geo API; it requires the CRS headers.
|
|
message.Headers.Add("Accept-Crs", "EPSG:4326");
|
|
message.Content.Headers.Add("Content-Crs", "EPSG:4326");
|
|
// OpenZaak runs behind uwsgi, which rejects a chunked request body with 400.
|
|
// JsonContent streams without a known length (→ Transfer-Encoding: chunked),
|
|
// so buffer it first to send a Content-Length instead. Only a real OpenZaak
|
|
// surfaces this — a stubbed HttpMessageHandler accepts either framing.
|
|
await message.Content.LoadIntoBufferAsync(ct);
|
|
|
|
using var response = await http.SendAsync(message, ct);
|
|
response.EnsureSuccessStatusCode();
|
|
|
|
var created = await response.Content.ReadFromJsonAsync<ZaakCreatedDto>(ct)
|
|
?? throw new InvalidOperationException("OpenZaak returned an empty zaak response");
|
|
return new Uri(created.Url);
|
|
}
|
|
|
|
public async Task SetZaakToEindstatusAsync(Uri zaakUrl, Uri zaaktypeUrl, DateOnly datumStatusGezet, CancellationToken ct = default)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(zaakUrl);
|
|
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);
|
|
|
|
// 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.
|
|
await PostAsync("/zaken/api/v1/resultaten",
|
|
new ResultaatDto(zaakUrl.ToString(), resultaattype.ToString()), "Setting the zaak resultaat", ct);
|
|
|
|
await PostAsync("/zaken/api/v1/statussen",
|
|
// datumStatusGezet is a ZGW date-time; set it at the start of the given day (UTC).
|
|
new StatusDto(zaakUrl.ToString(), eindstatus.ToString(),
|
|
datumStatusGezet.ToDateTime(TimeOnly.MinValue, DateTimeKind.Utc).ToString("yyyy-MM-ddTHH:mm:ssZ")),
|
|
"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);
|
|
|
|
using var message = new HttpRequestMessage(HttpMethod.Get, zaakUrl);
|
|
message.Headers.Authorization =
|
|
new AuthenticationHeaderValue("Bearer", ZgwToken.Mint(options.ClientId, options.Secret));
|
|
// The zaak is a geo resource; the Zaken API requires the CRS header even on GET.
|
|
message.Headers.Add("Accept-Crs", "EPSG:4326");
|
|
|
|
using var response = await http.SendAsync(message, ct);
|
|
await EnsureSuccessAsync(response, "Reading the zaak", ct);
|
|
|
|
var zaak = await response.Content.ReadFromJsonAsync<ZaakReadDto>(ct)
|
|
?? throw new InvalidOperationException("OpenZaak returned an empty zaak response");
|
|
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);
|
|
}
|
|
|
|
public Task<IReadOnlyList<ZaaktypeSummary>> ListZaaktypenAsync(CancellationToken ct = default) =>
|
|
// ponytail: stub for the red test; real Catalogi read lands in the green commit.
|
|
throw new NotImplementedException();
|
|
|
|
// 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)
|
|
{
|
|
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);
|
|
}
|
|
|
|
// 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)
|
|
{
|
|
if (response.IsSuccessStatusCode)
|
|
return;
|
|
|
|
var body = await response.Content.ReadAsStringAsync(ct);
|
|
throw new HttpRequestException($"{action} failed: {(int)response.StatusCode} {response.ReasonPhrase}. {body}");
|
|
}
|
|
|
|
/// <summary>Resolve the zaaktype's eindstatus (the terminal statustype) from the catalogus.</summary>
|
|
private async Task<Uri> ResolveEindstatusAsync(Uri zaaktypeUrl, CancellationToken ct)
|
|
{
|
|
var page = await GetCatalogusAsync<StatustypePage>("statustypen", zaaktypeUrl, "statustypen", ct);
|
|
var results = page.Results ?? [];
|
|
|
|
// OpenZaak flags the terminal statustype (highest volgnummer) as isEindstatus; fall back to the
|
|
// highest volgnummer if the flag is absent.
|
|
var eindstatus = results.FirstOrDefault(s => s.IsEindstatus)
|
|
?? results.OrderByDescending(s => s.Volgnummer).FirstOrDefault()
|
|
?? throw new InvalidOperationException($"No statustypen found for zaaktype {zaaktypeUrl}");
|
|
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)
|
|
{
|
|
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);
|
|
}
|
|
|
|
// GETs a catalogus collection filtered by zaaktype (status=alles includes concept + published).
|
|
private async Task<T> GetCatalogusAsync<T>(string resource, Uri zaaktypeUrl, string label, CancellationToken ct)
|
|
{
|
|
var query = new Uri(options.BaseUrl,
|
|
$"/catalogi/api/v1/{resource}?status=alles&zaaktype=" + Uri.EscapeDataString(zaaktypeUrl.ToString()));
|
|
using var message = new HttpRequestMessage(HttpMethod.Get, query);
|
|
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");
|
|
}
|
|
|
|
private sealed record ZaakDto(
|
|
[property: JsonPropertyName("bronorganisatie")] string Bronorganisatie,
|
|
[property: JsonPropertyName("zaaktype")] string Zaaktype,
|
|
[property: JsonPropertyName("verantwoordelijkeOrganisatie")] string VerantwoordelijkeOrganisatie,
|
|
[property: JsonPropertyName("startdatum")] string Startdatum,
|
|
[property: JsonPropertyName("vertrouwelijkheidaanduiding")] string Vertrouwelijkheidaanduiding,
|
|
[property: JsonPropertyName("identificatie")] string Identificatie);
|
|
|
|
private sealed record ZaakCreatedDto(
|
|
[property: JsonPropertyName("url")] string Url);
|
|
|
|
private sealed record ZaakReadDto(
|
|
[property: JsonPropertyName("identificatie")] string Identificatie);
|
|
|
|
private sealed record StatusDto(
|
|
[property: JsonPropertyName("zaak")] string Zaak,
|
|
[property: JsonPropertyName("statustype")] string Statustype,
|
|
[property: JsonPropertyName("datumStatusGezet")] string DatumStatusGezet);
|
|
|
|
private sealed record StatustypePage(
|
|
[property: JsonPropertyName("results")] IReadOnlyList<StatustypeDto>? Results);
|
|
|
|
private sealed record StatustypeDto(
|
|
[property: JsonPropertyName("url")] string Url,
|
|
[property: JsonPropertyName("volgnummer")] int Volgnummer,
|
|
[property: JsonPropertyName("isEindstatus")] bool IsEindstatus,
|
|
[property: JsonPropertyName("omschrijving")] string? Omschrijving);
|
|
|
|
private sealed record ResultaatDto(
|
|
[property: JsonPropertyName("zaak")] string Zaak,
|
|
[property: JsonPropertyName("resultaattype")] string Resultaattype);
|
|
|
|
private sealed record ResultaattypePage(
|
|
[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);
|
|
}
|