Notificatiedienst

```mermaid
classDiagram
    direction LR
    namespace domain {
        class Notificatie {
            +UUID id
            +UUID dvId
            +bytes dvRefHmac
            +int pepperVersie
            +bytes payloadHash
            +String berichtType
            +NotificatieStatus status
            +int versie
            +Reden laatsteReden
            +Instant geldigTot
            +UUID batchId
            +bytes ontvangerVersleuteld
            +bytes personalisatieVersleuteld
            +bytes sleutelGewrapt
            +Instant aangenomenOp
        }
        class Poging {
            +UUID id
            +UUID notificatieId
            +int nummer
            +PogingStatus status
            +UUID notifyNlId
            +List~UUID~ notifyNlIdDuplicaten
            +Instant verzondenOp
            +Instant receiptVoltooidOp
        }
        class Taak {
            +long id
            +TaakSoort soort
            +UUID dvId
            +UUID notificatieId
            +Instant due
            +Instant leaseTot
            +long claimEpoch
            +int pogingen
            +String traceId
            +TaakStatus status
            +jsonb payload
        }
        class Event {
            +long id
            +xid8 xactId
            +Instant tijdstip
            +UUID dvId
            +UUID notificatieId
            +int volgnummer
            +String van
            +String naar
            +Reden reden
        }
        class Dienstverlener {
            +UUID id
            +String oin
            +List~String~ berichttypen
            +int quotumPerDag
            +URL webhook
            +Duration bevestigingstermijn
            +Duration maxCursorleeftijd
            +String beheerkanaal
        }
        class Bevestiging {
            +UUID dvId
            +Cursor cursor
            +Instant bevestigdOp
        }
        class Webhookpositie {
            +UUID dvId
            +Cursor cursor
            +int mislukkingen
            +Instant gepauzeerdTot
        }
        class Budgettijdvak {
            +String notifyService
            +Instant tijdvak
            +int tokens
        }
        class Reden {
            <<enumeration>>
            onbereikbaar
            geen-contactgegevens
            verlopen
            geannuleerd
            technisch
        }
        class NotificatieStatus {
            <<enumeration>>
            aangenomen
            in-verzending
            verzonden
            bezorgd
            definitief-bezorgd
            niet-bezorgbaar
            technisch-mislukt
            bezorgstatus-onbekend
            verlopen
            geannuleerd
        }
        class PogingStatus {
            <<enumeration>>
            gepland
            verzonden
            bezorgd
            tijdelijk-mislukt
            permanent-mislukt
            technisch-mislukt
            onbekend
        }
        class TaakSoort {
            <<enumeration>>
            verzenden
            receipt-verwerken
            reconcilieren
            bezorging-vaststellen
            terugkoppelen
            ongeldig-melden
            wissen
            controle
            onderhoud
        }
        class TaakStatus {
            <<enumeration>>
            open
            mislukt
        }
    }
    Notificatie "1" --> "0..*" Poging
    Notificatie "1" --> "*" Taak
    Notificatie "1" --> "1..*" Event
    Notificatie ..> NotificatieStatus
    Poging ..> PogingStatus
    Taak ..> TaakSoort
    Taak ..> TaakStatus
    Notificatie ..> Reden
    Dienstverlener "1" --> "*" Notificatie
    Dienstverlener "1" --> "0..1" Bevestiging
    Dienstverlener "1" --> "0..1" Webhookpositie
```

```mermaid
stateDiagram-v2
    direction LR
    state "niet-bezorgbaar" as niet_bezorgbaar
    state "technisch-mislukt" as technisch_mislukt
    state "bezorgstatus-onbekend" as bezorgstatus_onbekend
    state "in-verzending" as in_verzending
    state "definitief-bezorgd" as definitief_bezorgd
    [*] --> aangenomen : aanname, 202
    aangenomen --> in_verzending : claim van de verzendtaak
    aangenomen --> verlopen : geldig_tot verstreken
    aangenomen --> geannuleerd : annulering
    in_verzending --> verzonden : NotifyNL 201, of receipt vóór de verzend-commit
    in_verzending --> technisch_mislukt : verzendtaak uitgeput
    in_verzending --> verlopen : geldig_tot verstreken tijdens uitstel
    in_verzending --> niet_bezorgbaar : geen contactgegevens of 4xx over adres of partij
    verzonden --> verzonden : nieuwe poging
    verzonden --> verlopen : faalreceipt of uitstel na geldig_tot
    verzonden --> bezorgd : receipt delivered
    verzonden --> niet_bezorgbaar : permanent-failure of 2e temporary-failure
    verzonden --> technisch_mislukt : 2e technical-failure of verzendtaak uitgeput
    verzonden --> bezorgstatus_onbekend : 404 bij NotifyNL of bewaartermijn NotifyNL verstreken
    bezorgstatus_onbekend --> bezorgd : laat event
    bezorgstatus_onbekend --> niet_bezorgbaar : laat event
    bezorgd --> definitief_bezorgd : vaststellingstermijn verstreken
    bezorgd --> verzonden : temporary-failure binnen de vaststellingstermijn, herverzendtaak gepland
    bezorgd --> niet_bezorgbaar : permanent-failure of 2e temporary-failure binnen de vaststellingstermijn
    bezorgd --> verlopen : faalreceipt na geldig_tot
    definitief_bezorgd --> [*]
    niet_bezorgbaar --> [*]
    technisch_mislukt --> [*]
    verlopen --> [*]
    geannuleerd --> [*]
```

```mermaid
classDiagram
    direction TB
    namespace levenscyclus {
        class AannameService {
            +aannemen(Dv dv, AannameOpdracht opdracht) UUID
        }
        class Dienstverlenerregister {
            +opOin(String oin) Dienstverlener
            +toets(Dv dv, String berichtType)
        }
        class Overgangsfunctie {
            +status(UUID notificatieId, NotificatieStatus naar, Reden reden) OvergangUitkomst
            -vergrendel(UUID notificatieId) Notificatie
        }
        class Overgangsregels {
            +toegestaan(van, naar) boolean
            +uitReceipt(Poging poging, Receipt receipt) Overgang
        }
        class OvergangUitkomst {
            <<enumeration>>
            uitgevoerd
            no-op
        }
        class ReceiptVerwerker {
            +verwerk(InkomendEvent event)
        }
        class Reconciler {
            +reconcilieer(List~Poging~ pogingen)
        }
        class Templateregister {
            +template(String berichtType) TemplateId
        }
        class Verwerkingslog {
            +registreer(Taak t, Verwerking v)
        }
    }
    namespace taak {
        class TaakWorker {
            +run()
        }
        class TaakClaimer {
            +claim(TaakSoort soort, int batch) List~Taak~
            +verleng(Taak t)
            +afronden(Taak t)
            +uitstellen(Taak t, Instant due)
            +uitgeput(Taak t)
        }
        class Verzendbudget {
            +neem(String notifyService, Instant tijdvak, int n) int
        }
        class TaakHandler {
            <<interface>>
            +soort() TaakSoort
            +voerUit(Taak t)
        }
        class VerzendTaakHandler
        class ReceiptTaakHandler
        class ReconciliatieTaakHandler
        class BezorgingVaststellenTaakHandler
        class TerugkoppelTaakHandler
        class OngeldigMeldenTaakHandler
        class WisTaakHandler
        class ControleTaakHandler
        class OnderhoudTaakHandler
    }
    namespace terugkoppeling {
        class Eventfeed {
            +lees(UUID dvId, Cursor cursor, int limiet) EventPagina
            +bevestig(UUID dvId, Cursor cursor)
        }
        class WebhookDispatcher {
            +dispatch(UUID dvId)
        }
        class Cursor {
            +long epoch
            +xid8 xactId
            +long eventId
        }
    }
    TaakWorker --> TaakClaimer
    TaakWorker --> TaakHandler
    TaakClaimer --> Verzendbudget
    TaakHandler <|.. VerzendTaakHandler
    TaakHandler <|.. ReceiptTaakHandler
    TaakHandler <|.. ReconciliatieTaakHandler
    TaakHandler <|.. BezorgingVaststellenTaakHandler
    TaakHandler <|.. TerugkoppelTaakHandler
    TaakHandler <|.. OngeldigMeldenTaakHandler
    TaakHandler <|.. WisTaakHandler
    TaakHandler <|.. ControleTaakHandler
    TaakHandler <|.. OnderhoudTaakHandler
    AannameService --> Overgangsfunctie
    AannameService --> Templateregister
    AannameService --> Dienstverlenerregister
    VerzendTaakHandler --> Overgangsfunctie
    VerzendTaakHandler --> Templateregister
    VerzendTaakHandler --> Verwerkingslog
    ReconciliatieTaakHandler --> Verwerkingslog
    OngeldigMeldenTaakHandler --> Verwerkingslog
    TerugkoppelTaakHandler --> Verwerkingslog
    Eventfeed --> Verwerkingslog
    TerugkoppelTaakHandler --> WebhookDispatcher
    ReceiptTaakHandler --> ReceiptVerwerker
    ReceiptVerwerker --> Overgangsregels
    ReceiptVerwerker --> Overgangsfunctie
    ReconciliatieTaakHandler --> Reconciler
    Reconciler --> Overgangsfunctie
    BezorgingVaststellenTaakHandler --> Overgangsfunctie
    Overgangsfunctie --> Overgangsregels
    Overgangsfunctie ..> OvergangUitkomst
    WebhookDispatcher --> Eventfeed
    Eventfeed ..> Cursor
```

```mermaid
classDiagram
    direction LR
    namespace controller {
        class CentraleNotificatieController {
            +aannemen(Dv dv, CentraleAanname body) NotificatieId
        }
        class DecentraleNotificatieController {
            +aannemen(Dv dv, DecentraleAanname body) NotificatieId
        }
        class NotificatieStatusController {
            +status(Dv dv, UUID id) NotificatieStatusResponse
            +zoeken(Dv dv, String dvRef) List~NotificatieStatusResponse~
            +annuleren(Dv dv, UUID id)
        }
        class EventfeedController {
            +wijzigingen(Dv dv, String cursor, int limiet) CloudEventsPagina
            +bevestigen(Dv dv, String cursor)
        }
    }
    namespace inkomend {
        class NotifyNLCallbackController {
            +receipt(Receipt r)
        }
        class InkomendEventOpslag {
            +slaOp(Bron bron, UUID pogingId, Object payloadZonderPii) Taak
        }
    }
    namespace client {
        class NotifyNLVerzendAdapter {
            +verstuur(Poging p, TemplateId template, Map personalisation) UUID
            +zoekOpReference(Poging p) Receipt
            +statussen(List~Poging~ pogingen) List~Receipt~
        }
        class ProfielServiceAdapter {
            +voorkeur(PartijIdentificatie id) Voorkeur
            +meldOngeldig(PartijIdentificatie id)
        }
        class ConsumentCallbackAdapter {
            +lever(Dienstverlener dv, List~Event~ events)
        }
    }
    namespace repository {
        class NotificatieRepository
        class PogingRepository
        class TaakRepository
        class EventRepository
        class DienstverlenerRepository
        class BevestigingRepository
    }
    namespace crypto {
        class Sleutelbeheer {
            +versleutel(UUID notificatieId, bytes waarde) bytes
            +ontsleutel(UUID notificatieId, bytes waarde) bytes
            +wis(UUID notificatieId)
        }
        class HashHelper {
            +hmac(Doel doel, int pepperVersie, String... waarden) bytes
        }
    }
    namespace levenscyclus {
        class AannameService
        class Overgangsfunctie
        class Reconciler
        class Eventfeed
        class WebhookDispatcher
        class VerzendTaakHandler
        class OngeldigMeldenTaakHandler
        class WisTaakHandler
        class Dienstverlenerregister
    }
    CentraleNotificatieController --> AannameService
    DecentraleNotificatieController --> AannameService
    NotificatieStatusController --> Overgangsfunctie : annuleren
    NotificatieStatusController --> NotificatieRepository
    Dienstverlenerregister --> DienstverlenerRepository
    EventfeedController --> Eventfeed
    Eventfeed --> BevestigingRepository
    NotifyNLCallbackController --> InkomendEventOpslag
    InkomendEventOpslag --> TaakRepository
    AannameService --> HashHelper
    AannameService --> Sleutelbeheer
    VerzendTaakHandler --> ProfielServiceAdapter
    VerzendTaakHandler --> NotifyNLVerzendAdapter
    Reconciler --> NotifyNLVerzendAdapter
    OngeldigMeldenTaakHandler --> ProfielServiceAdapter
    VerzendTaakHandler --> Sleutelbeheer
    OngeldigMeldenTaakHandler --> Sleutelbeheer
    WisTaakHandler --> Sleutelbeheer
    WebhookDispatcher --> ConsumentCallbackAdapter
    Overgangsfunctie --> NotificatieRepository
    Overgangsfunctie --> PogingRepository
    Eventfeed --> EventRepository
```