CFG-03: benachrichtigungs-kanaele-e-mail-in-app
internal/channels: konkrete Zustellkanaele fuer CFG-02s Dispatcher.
TemplateStore.Resolve loest Vorlagen pro Tenant auf und faellt auf
GlobalTemplateScope zurueck, wenn ein Tenant keine eigene gesetzt hat
(Akzeptanzkriterium 3). Render nutzt text/template mit
Option("missingkey=error") — ein fehlender Platzhalter bricht das Rendering
MIT FEHLER ab, statt eine unvollstaendige Nachricht zu erzeugen
(Akzeptanzkriterium 1).
EmailSender implementiert notify.Sender: rendert ZUERST die Vorlage, bevor
ueberhaupt eine SMTP-Verbindung aufgebaut wird — schlaegt das Rendering
fehl, wird nie ein Netzwerkzugriff versucht. Ein anschliessend fehl-
schlagender SMTP-Versand liefert einen Fehler, den CFG-02s bereits
getestete Wiederholungslogik verarbeitet (kein zweiter Retry-Mechanismus
hier). InAppSender persistiert In-App-Nachrichten ueber InAppStore
(Akzeptanzkriterium 2, ueber API abrufbar/als gelesen markierbar). Router
waehlt den Kanal anhand Notification.Channel — ein neuer Kanal wird per
Register() ergaenzt, ohne Dispatcher oder Router umzubauen.
Pruefungen (ausgefuehrt auf root@192.168.1.131, go build/vet/test PASS):
1. Vorlagenrendering mit fehlenden Platzhaltern bricht kontrolliert ab —
TestRender_MissingPlaceholderAborts und
TestEmailSender_AbortsBeforeSMTPWhenTemplateMissing (Fehler kommt von der
Vorlagenaufloesung, kein SMTP-Verbindungsversuch). PASS.
2. In-App-Benachrichtigung nach Markierung als gelesen korrekt gefuehrt —
TestInAppStore_MarkReadIsReflectedCorrectly. PASS.
3. E-Mail-Versand bei nicht erreichbarem SMTP-Server loest dokumentiertes
Retry-Verhalten ueber CFG-02 aus —
TestEmailSender_TriggersDispatcherRetryOnUnreachableSMTP: echter
EmailSender gegen unerreichbaren Host, ueber notify.Dispatcher
eingereiht, nach ausgeschoepften Wiederholungen status=failed mit
korrekter Versuchszahl. PASS.
Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
sysops
co-authored by
Claude Sonnet 5
Claude Sonnet 5
parent
6f532d8350
commit
034865f5a0
@@ -0,0 +1,207 @@
|
||||
package channels
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/notify"
|
||||
)
|
||||
|
||||
func setupTest(t *testing.T) (*TemplateStore, *InAppStore, func()) {
|
||||
t.Helper()
|
||||
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||
if adminDSN == "" {
|
||||
t.Skip("TEST_ADMIN_DSN nicht gesetzt, Integrationstest uebersprungen")
|
||||
}
|
||||
ctx := context.Background()
|
||||
|
||||
pool, err := pgxpool.New(ctx, adminDSN)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
if _, err := pool.Exec(ctx, `
|
||||
CREATE TABLE IF NOT EXISTS notification_templates (
|
||||
tenant_slug TEXT NOT NULL, key TEXT NOT NULL, subject TEXT NOT NULL, body TEXT NOT NULL,
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (tenant_slug, key)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS in_app_notifications (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(), tenant_slug TEXT NOT NULL, user_id TEXT NOT NULL,
|
||||
title TEXT NOT NULL, body TEXT NOT NULL, read_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS notification_jobs (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(), channel TEXT NOT NULL, recipient TEXT NOT NULL,
|
||||
payload JSONB NOT NULL DEFAULT '{}'::jsonb, status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','sent','failed')),
|
||||
attempts INT NOT NULL DEFAULT 0, max_attempts INT NOT NULL DEFAULT 5,
|
||||
next_attempt_at TIMESTAMPTZ NOT NULL DEFAULT now(), last_error TEXT,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(), updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
`); err != nil {
|
||||
t.Fatalf("schema: %v", err)
|
||||
}
|
||||
|
||||
cleanup := func() { pool.Close() }
|
||||
return NewTemplateStore(pool), NewInAppStore(pool), cleanup
|
||||
}
|
||||
|
||||
func uniqueKey(prefix string) string {
|
||||
return fmt.Sprintf("%s_%d", prefix, time.Now().UnixNano())
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 1 + Pruefung 1: Vorlagenrendering mit fehlenden
|
||||
// Platzhaltern bricht kontrolliert ab.
|
||||
func TestRender_MissingPlaceholderAborts(t *testing.T) {
|
||||
tmpl := Template{Subject: "Hallo {{.name}}", Body: "Dein Code: {{.code}}"}
|
||||
|
||||
_, _, err := Render(tmpl, map[string]any{"name": "Alice"}) // "code" fehlt
|
||||
if err == nil {
|
||||
t.Fatal("erwartet fehler bei fehlendem platzhalter 'code'")
|
||||
}
|
||||
}
|
||||
|
||||
func TestRender_SucceedsWithAllPlaceholders(t *testing.T) {
|
||||
tmpl := Template{Subject: "Hallo {{.name}}", Body: "Dein Code: {{.code}}"}
|
||||
|
||||
subject, body, err := Render(tmpl, map[string]any{"name": "Alice", "code": "1234"})
|
||||
if err != nil {
|
||||
t.Fatalf("render: %v", err)
|
||||
}
|
||||
if subject != "Hallo Alice" || body != "Dein Code: 1234" {
|
||||
t.Fatalf("unerwartet: subject=%q body=%q", subject, body)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 3: Vorlagen pro Tenant anpassbar, Fallback auf global.
|
||||
func TestTemplateStore_TenantOverrideFallsBackToGlobal(t *testing.T) {
|
||||
templates, _, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
key := uniqueKey("welcome")
|
||||
if err := templates.Set(ctx, GlobalTemplateScope, key, "Willkommen", "Standardtext"); err != nil {
|
||||
t.Fatalf("set global: %v", err)
|
||||
}
|
||||
if err := templates.Set(ctx, "acme", key, "Willkommen bei ACME", "ACME-Text"); err != nil {
|
||||
t.Fatalf("set tenant: %v", err)
|
||||
}
|
||||
|
||||
got, err := templates.Resolve(ctx, "acme", key)
|
||||
if err != nil {
|
||||
t.Fatalf("resolve acme: %v", err)
|
||||
}
|
||||
if got.Subject != "Willkommen bei ACME" {
|
||||
t.Fatalf("erwartet tenant-vorlage, habe %q", got.Subject)
|
||||
}
|
||||
|
||||
got, err = templates.Resolve(ctx, "globex", key) // hat keine eigene vorlage
|
||||
if err != nil {
|
||||
t.Fatalf("resolve globex: %v", err)
|
||||
}
|
||||
if got.Subject != "Willkommen" {
|
||||
t.Fatalf("erwartet global-fallback, habe %q", got.Subject)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 2 + Pruefung 2: als gelesen markiert wird korrekt gefuehrt.
|
||||
func TestInAppStore_MarkReadIsReflectedCorrectly(t *testing.T) {
|
||||
_, inApp, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
userID := uniqueKey("user")
|
||||
id, err := inApp.Create(ctx, "acme", userID, "Titel", "Text")
|
||||
if err != nil {
|
||||
t.Fatalf("create: %v", err)
|
||||
}
|
||||
|
||||
list, err := inApp.ListForUser(ctx, "acme", userID)
|
||||
if err != nil {
|
||||
t.Fatalf("list (vor markierung): %v", err)
|
||||
}
|
||||
if len(list) != 1 || list[0].ReadAt != nil {
|
||||
t.Fatalf("erwartet 1 ungelesene benachrichtigung, habe %+v", list)
|
||||
}
|
||||
|
||||
if err := inApp.MarkRead(ctx, id); err != nil {
|
||||
t.Fatalf("mark read: %v", err)
|
||||
}
|
||||
|
||||
list, err = inApp.ListForUser(ctx, "acme", userID)
|
||||
if err != nil {
|
||||
t.Fatalf("list (nach markierung): %v", err)
|
||||
}
|
||||
if len(list) != 1 || list[0].ReadAt == nil {
|
||||
t.Fatalf("erwartet als gelesen markiert, habe %+v", list)
|
||||
}
|
||||
}
|
||||
|
||||
// EmailSender bricht ab, BEVOR SMTP ueberhaupt kontaktiert wird, wenn keine
|
||||
// Vorlage aufloesbar ist — Nachweis, dass der Abbruch vor dem Netzwerkzugriff
|
||||
// erfolgt (Akzeptanzkriterium 1).
|
||||
func TestEmailSender_AbortsBeforeSMTPWhenTemplateMissing(t *testing.T) {
|
||||
templates, _, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
sender := NewEmailSender(templates, "nicht-aufloesbarer-smtp-host.invalid", "25", "noreply@example.com")
|
||||
|
||||
err := sender.Send(ctx, notify.Notification{
|
||||
Recipient: "user@example.com",
|
||||
Payload: map[string]any{"template_key": uniqueKey("nie_konfiguriert"), "tenant_slug": "acme"},
|
||||
})
|
||||
if !errors.Is(err, ErrTemplateNotFound) {
|
||||
t.Fatalf("erwartet ErrTemplateNotFound (kein smtp-versuch), habe %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// Akzeptanzkriterium 3 + Pruefung 3: E-Mail-Versand bei nicht erreichbarem
|
||||
// SMTP-Server loest das dokumentierte Retry-Verhalten ueber CFG-02 aus.
|
||||
func TestEmailSender_TriggersDispatcherRetryOnUnreachableSMTP(t *testing.T) {
|
||||
templates, _, cleanup := setupTest(t)
|
||||
defer cleanup()
|
||||
ctx := context.Background()
|
||||
|
||||
adminDSN := os.Getenv("TEST_ADMIN_DSN")
|
||||
pool, err := pgxpool.New(ctx, adminDSN)
|
||||
if err != nil {
|
||||
t.Fatalf("pool: %v", err)
|
||||
}
|
||||
defer pool.Close()
|
||||
|
||||
key := uniqueKey("retry_test")
|
||||
if err := templates.Set(ctx, GlobalTemplateScope, key, "Betreff", "Text ohne Platzhalter"); err != nil {
|
||||
t.Fatalf("set template: %v", err)
|
||||
}
|
||||
|
||||
sender := NewEmailSender(templates, "nicht-aufloesbarer-smtp-host.invalid", "25", "noreply@example.com")
|
||||
dispatcher := notify.NewDispatcher(pool).WithRetryPolicy(2, time.Millisecond)
|
||||
|
||||
jobID, err := dispatcher.Enqueue(ctx, "email", "user@example.com", map[string]any{"template_key": key, "tenant_slug": "acme"})
|
||||
if err != nil {
|
||||
t.Fatalf("enqueue: %v", err)
|
||||
}
|
||||
|
||||
for i := 0; i < 2; i++ {
|
||||
time.Sleep(5 * time.Millisecond)
|
||||
if _, _, err := dispatcher.ProcessDue(ctx, sender, 10); err != nil {
|
||||
t.Fatalf("process due %d: %v", i, err)
|
||||
}
|
||||
}
|
||||
|
||||
var status string
|
||||
var attempts int
|
||||
if err := pool.QueryRow(ctx, `SELECT status, attempts FROM notification_jobs WHERE id = $1`, jobID).Scan(&status, &attempts); err != nil {
|
||||
t.Fatalf("status lesen: %v", err)
|
||||
}
|
||||
if status != "failed" {
|
||||
t.Fatalf("erwartet status failed nach ausgeschoepften wiederholungen bei unerreichbarem smtp, habe %q", status)
|
||||
}
|
||||
if attempts != 2 {
|
||||
t.Fatalf("erwartet 2 versuche, habe %d", attempts)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package channels
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net/smtp"
|
||||
"os"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/notify"
|
||||
)
|
||||
|
||||
// EmailSender implementiert notify.Sender fuer den E-Mail-Kanal
|
||||
// (Akzeptanzkriterium 1). SMTP-Zugangsdaten kommen ausschliesslich aus
|
||||
// Umgebungsvariablen, nie aus Code/DB.
|
||||
type EmailSender struct {
|
||||
templates *TemplateStore
|
||||
host string
|
||||
port string
|
||||
from string
|
||||
username string
|
||||
password string
|
||||
}
|
||||
|
||||
// NewEmailSenderFromEnv liest NEXARCH_SMTP_HOST/PORT/FROM (Pflicht) sowie
|
||||
// optional NEXARCH_SMTP_USER/PASSWORD.
|
||||
func NewEmailSenderFromEnv(templates *TemplateStore) (*EmailSender, error) {
|
||||
host := os.Getenv("NEXARCH_SMTP_HOST")
|
||||
port := os.Getenv("NEXARCH_SMTP_PORT")
|
||||
from := os.Getenv("NEXARCH_SMTP_FROM")
|
||||
if host == "" || port == "" || from == "" {
|
||||
return nil, fmt.Errorf("channels: NEXARCH_SMTP_HOST/PORT/FROM muessen gesetzt sein")
|
||||
}
|
||||
return &EmailSender{
|
||||
templates: templates,
|
||||
host: host,
|
||||
port: port,
|
||||
from: from,
|
||||
username: os.Getenv("NEXARCH_SMTP_USER"),
|
||||
password: os.Getenv("NEXARCH_SMTP_PASSWORD"),
|
||||
}, nil
|
||||
}
|
||||
|
||||
// NewEmailSender erlaubt Tests, Host/Port explizit zu setzen (z.B. einen
|
||||
// absichtlich nicht erreichbaren Host fuer den Retry-Nachweis), ohne
|
||||
// Umgebungsvariablen zu benoetigen.
|
||||
func NewEmailSender(templates *TemplateStore, host, port, from string) *EmailSender {
|
||||
return &EmailSender{templates: templates, host: host, port: port, from: from}
|
||||
}
|
||||
|
||||
// Send rendert zuerst die Vorlage — schlaegt das fehl (z.B. fehlender
|
||||
// Platzhalter), wird NIE eine SMTP-Verbindung aufgebaut
|
||||
// (Akzeptanzkriterium 1 / Pruefung 1: kontrollierter Abbruch statt
|
||||
// fehlerhafter Mail). Ein danach fehlschlagender SMTP-Versand liefert einen
|
||||
// Fehler zurueck, den CFG-02s Dispatcher fuer die bereits getestete
|
||||
// Wiederholungslogik nutzt (Akzeptanzkriterium 3 / Pruefung 3) — kein
|
||||
// zweiter Retry-Mechanismus hier.
|
||||
func (e *EmailSender) Send(ctx context.Context, n notify.Notification) error {
|
||||
templateKey, _ := n.Payload["template_key"].(string)
|
||||
tenantSlug, _ := n.Payload["tenant_slug"].(string)
|
||||
|
||||
tmpl, err := e.templates.Resolve(ctx, tenantSlug, templateKey)
|
||||
if err != nil {
|
||||
return fmt.Errorf("vorlage aufloesen: %w", err)
|
||||
}
|
||||
subject, body, err := Render(tmpl, n.Payload)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
msg := []byte("Subject: " + subject + "\r\n\r\n" + body)
|
||||
|
||||
var auth smtp.Auth
|
||||
if e.username != "" {
|
||||
auth = smtp.PlainAuth("", e.username, e.password, e.host)
|
||||
}
|
||||
addr := e.host + ":" + e.port
|
||||
if err := smtp.SendMail(addr, auth, e.from, []string{n.Recipient}, msg); err != nil {
|
||||
return fmt.Errorf("smtp-versand fehlgeschlagen: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
package channels
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
type InAppNotification struct {
|
||||
ID string
|
||||
TenantSlug string
|
||||
UserID string
|
||||
Title string
|
||||
Body string
|
||||
ReadAt *time.Time
|
||||
CreatedAt time.Time
|
||||
}
|
||||
|
||||
// InAppStore persistiert In-App-Benachrichtigungen (Akzeptanzkriterium 2).
|
||||
type InAppStore struct {
|
||||
pool *pgxpool.Pool
|
||||
}
|
||||
|
||||
func NewInAppStore(pool *pgxpool.Pool) *InAppStore {
|
||||
return &InAppStore{pool: pool}
|
||||
}
|
||||
|
||||
func (s *InAppStore) Create(ctx context.Context, tenantSlug, userID, title, body string) (string, error) {
|
||||
var id string
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
INSERT INTO in_app_notifications (tenant_slug, user_id, title, body)
|
||||
VALUES ($1, $2, $3, $4)
|
||||
RETURNING id
|
||||
`, tenantSlug, userID, title, body).Scan(&id)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("in-app-benachrichtigung speichern: %w", err)
|
||||
}
|
||||
return id, nil
|
||||
}
|
||||
|
||||
// ListForUser liefert alle Benachrichtigungen eines Benutzers (ueber API
|
||||
// abrufbar, Akzeptanzkriterium 2).
|
||||
func (s *InAppStore) ListForUser(ctx context.Context, tenantSlug, userID string) ([]InAppNotification, error) {
|
||||
rows, err := s.pool.Query(ctx, `
|
||||
SELECT id, title, body, read_at, created_at FROM in_app_notifications
|
||||
WHERE tenant_slug = $1 AND user_id = $2 ORDER BY created_at DESC
|
||||
`, tenantSlug, userID)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("benachrichtigungen auflisten: %w", err)
|
||||
}
|
||||
defer rows.Close()
|
||||
|
||||
var out []InAppNotification
|
||||
for rows.Next() {
|
||||
n := InAppNotification{TenantSlug: tenantSlug, UserID: userID}
|
||||
if err := rows.Scan(&n.ID, &n.Title, &n.Body, &n.ReadAt, &n.CreatedAt); err != nil {
|
||||
return nil, fmt.Errorf("benachrichtigung lesen: %w", err)
|
||||
}
|
||||
out = append(out, n)
|
||||
}
|
||||
return out, rows.Err()
|
||||
}
|
||||
|
||||
// MarkRead markiert eine Benachrichtigung als gelesen (Akzeptanzkriterium 2
|
||||
// / Pruefung 2).
|
||||
func (s *InAppStore) MarkRead(ctx context.Context, id string) error {
|
||||
_, err := s.pool.Exec(ctx, `UPDATE in_app_notifications SET read_at = now() WHERE id = $1`, id)
|
||||
if err != nil {
|
||||
return fmt.Errorf("als gelesen markieren: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
package channels
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/notify"
|
||||
)
|
||||
|
||||
// InAppSender implementiert notify.Sender fuer den In-App-Kanal
|
||||
// (Akzeptanzkriterium 2). Nutzt eine Vorlage, falls payload["template_key"]
|
||||
// gesetzt ist, sonst direkt payload["title"]/["body"].
|
||||
type InAppSender struct {
|
||||
store *InAppStore
|
||||
templates *TemplateStore
|
||||
}
|
||||
|
||||
func NewInAppSender(store *InAppStore, templates *TemplateStore) *InAppSender {
|
||||
return &InAppSender{store: store, templates: templates}
|
||||
}
|
||||
|
||||
func (s *InAppSender) Send(ctx context.Context, n notify.Notification) error {
|
||||
tenantSlug, _ := n.Payload["tenant_slug"].(string)
|
||||
|
||||
var title, body string
|
||||
if templateKey, ok := n.Payload["template_key"].(string); ok && templateKey != "" {
|
||||
tmpl, err := s.templates.Resolve(ctx, tenantSlug, templateKey)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
title, body, err = Render(tmpl, n.Payload)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
} else {
|
||||
title, _ = n.Payload["title"].(string)
|
||||
body, _ = n.Payload["body"].(string)
|
||||
}
|
||||
|
||||
_, err := s.store.Create(ctx, tenantSlug, n.Recipient, title, body)
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
package channels
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"gitea.perlbach24.de/scripte/nexarch/internal/notify"
|
||||
)
|
||||
|
||||
// Router waehlt anhand von Notification.Channel den zustaendigen Kanal aus
|
||||
// — ein neuer Kanal wird per Register() ergaenzt, ohne den Dispatcher
|
||||
// (CFG-02) oder Router selbst umzubauen (Unleash-artiger Strategie-Gedanke,
|
||||
// siehe Ticket-DNA).
|
||||
type Router struct {
|
||||
channels map[string]notify.Sender
|
||||
}
|
||||
|
||||
func NewRouter() *Router {
|
||||
return &Router{channels: make(map[string]notify.Sender)}
|
||||
}
|
||||
|
||||
func (r *Router) Register(channel string, sender notify.Sender) {
|
||||
r.channels[channel] = sender
|
||||
}
|
||||
|
||||
func (r *Router) Send(ctx context.Context, n notify.Notification) error {
|
||||
sender, ok := r.channels[n.Channel]
|
||||
if !ok {
|
||||
return fmt.Errorf("channels: unbekannter kanal %q", n.Channel)
|
||||
}
|
||||
return sender.Send(ctx, n)
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
// Package channels implementiert Core CFG-03: konkrete Zustellkanaele fuer
|
||||
// den CFG-02-Dispatcher (E-Mail, In-App) inklusive Vorlagenverwaltung.
|
||||
// Neue Kanaele lassen sich ergaenzen, ohne den Dispatcher selbst
|
||||
// anzufassen — jeder Kanal implementiert nur notify.Sender.
|
||||
package channels
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"text/template"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
// GlobalTemplateScope ist der Fallback-Wert, wenn ein Tenant keine eigene
|
||||
// Vorlage konfiguriert hat (Akzeptanzkriterium 3).
|
||||
const GlobalTemplateScope = "global"
|
||||
|
||||
var ErrTemplateNotFound = errors.New("channels: keine vorlage gefunden")
|
||||
|
||||
type Template struct {
|
||||
Subject string
|
||||
Body string
|
||||
}
|
||||
|
||||
type TemplateStore struct {
|
||||
pool *pgxpool.Pool
|
||||
}
|
||||
|
||||
func NewTemplateStore(pool *pgxpool.Pool) *TemplateStore {
|
||||
return &TemplateStore{pool: pool}
|
||||
}
|
||||
|
||||
// Set legt eine Vorlage fuer einen Tenant (oder GlobalTemplateScope) fest.
|
||||
func (s *TemplateStore) Set(ctx context.Context, tenantSlug, key, subject, body string) error {
|
||||
_, err := s.pool.Exec(ctx, `
|
||||
INSERT INTO notification_templates (tenant_slug, key, subject, body, updated_at)
|
||||
VALUES ($1, $2, $3, $4, now())
|
||||
ON CONFLICT (tenant_slug, key) DO UPDATE SET subject = $3, body = $4, updated_at = now()
|
||||
`, tenantSlug, key, subject, body)
|
||||
if err != nil {
|
||||
return fmt.Errorf("vorlage speichern: %w", err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// Resolve liefert die Vorlage eines Tenants, faellt auf GlobalTemplateScope
|
||||
// zurueck, wenn der Tenant keine eigene gesetzt hat (Akzeptanzkriterium 3).
|
||||
func (s *TemplateStore) Resolve(ctx context.Context, tenantSlug, key string) (Template, error) {
|
||||
if tenantSlug != "" && tenantSlug != GlobalTemplateScope {
|
||||
if t, err := s.get(ctx, tenantSlug, key); err == nil {
|
||||
return t, nil
|
||||
} else if !errors.Is(err, ErrTemplateNotFound) {
|
||||
return Template{}, err
|
||||
}
|
||||
}
|
||||
return s.get(ctx, GlobalTemplateScope, key)
|
||||
}
|
||||
|
||||
func (s *TemplateStore) get(ctx context.Context, tenantSlug, key string) (Template, error) {
|
||||
var t Template
|
||||
err := s.pool.QueryRow(ctx, `
|
||||
SELECT subject, body FROM notification_templates WHERE tenant_slug = $1 AND key = $2
|
||||
`, tenantSlug, key).Scan(&t.Subject, &t.Body)
|
||||
if err != nil {
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return Template{}, ErrTemplateNotFound
|
||||
}
|
||||
return Template{}, fmt.Errorf("vorlage lesen: %w", err)
|
||||
}
|
||||
return t, nil
|
||||
}
|
||||
|
||||
// Render fuellt eine Vorlage mit data. Fehlt ein referenzierter Platzhalter
|
||||
// in data, bricht das Rendering kontrolliert MIT FEHLER ab, statt eine
|
||||
// fehlerhafte/unvollstaendige Nachricht zu erzeugen (Akzeptanzkriterium 1 /
|
||||
// Pruefung 1) — text/template mit Option("missingkey=error") liefert dafuer
|
||||
// einen Fehler statt stillschweigend "<no value>" einzusetzen.
|
||||
func Render(tmpl Template, data map[string]any) (subject, body string, err error) {
|
||||
subject, err = renderOne("subject", tmpl.Subject, data)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
body, err = renderOne("body", tmpl.Body, data)
|
||||
if err != nil {
|
||||
return "", "", err
|
||||
}
|
||||
return subject, body, nil
|
||||
}
|
||||
|
||||
func renderOne(name, text string, data map[string]any) (string, error) {
|
||||
tmpl, err := template.New(name).Option("missingkey=error").Parse(text)
|
||||
if err != nil {
|
||||
return "", fmt.Errorf("vorlage %q parsen: %w", name, err)
|
||||
}
|
||||
var buf bytes.Buffer
|
||||
if err := tmpl.Execute(&buf, data); err != nil {
|
||||
return "", fmt.Errorf("vorlage %q rendern (fehlender platzhalter?): %w", name, err)
|
||||
}
|
||||
return buf.String(), nil
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
DROP TABLE IF EXISTS in_app_notifications;
|
||||
DROP TABLE IF EXISTS notification_templates;
|
||||
@@ -0,0 +1,28 @@
|
||||
-- Benachrichtigungs-Kanaele: Vorlagen (E-Mail) + In-App-Nachrichten
|
||||
-- (CFG-03, siehe core-kanban/tickets/CFG-03.md). Beide leben in der
|
||||
-- Registry-DB, analog zu feature_flags/config_values — modulübergreifende
|
||||
-- Konfiguration/UI-Zustand, keine Mandanten-Geschaeftsdaten.
|
||||
|
||||
-- tenant_slug = 'global' ist der Fallback-Wert, wenn ein Tenant keine
|
||||
-- eigene Vorlage gesetzt hat (Akzeptanzkriterium 3: Vorlagen pro Tenant
|
||||
-- anpassbar, mit sinnvollem Default).
|
||||
CREATE TABLE notification_templates (
|
||||
tenant_slug TEXT NOT NULL,
|
||||
key TEXT NOT NULL,
|
||||
subject TEXT NOT NULL,
|
||||
body TEXT NOT NULL,
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (tenant_slug, key)
|
||||
);
|
||||
|
||||
CREATE TABLE in_app_notifications (
|
||||
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
|
||||
tenant_slug TEXT NOT NULL,
|
||||
user_id TEXT NOT NULL,
|
||||
title TEXT NOT NULL,
|
||||
body TEXT NOT NULL,
|
||||
read_at TIMESTAMPTZ,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
|
||||
CREATE INDEX in_app_notifications_user_idx ON in_app_notifications (tenant_slug, user_id, created_at);
|
||||
@@ -1,26 +1,11 @@
|
||||
#!/usr/bin/env bash
|
||||
# Setzt die nexarch-Testumgebung zurueck: loescht die geteilte
|
||||
# Registry-Tabelle "tenants" in der postgres-Wartungsdatenbank sowie alle
|
||||
# tenant_*-Datenbanken. Noetig, weil verschiedene Feature-Branches
|
||||
# unterschiedliche Registry-Schemata erwarten, aber dieselbe physische
|
||||
# Postgres-Instanz auf dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
|
||||
#
|
||||
# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/reset-test-env.sh
|
||||
set -euo pipefail
|
||||
|
||||
PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
|
||||
ROLE="nexarch_test"
|
||||
|
||||
export PGPASSWORD="$PASS"
|
||||
|
||||
psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS tenants CASCADE;"
|
||||
psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS audit_events CASCADE;"
|
||||
psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS config_value_history CASCADE;"
|
||||
psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP TABLE IF EXISTS config_values CASCADE;"
|
||||
|
||||
dbs=$(psql -h localhost -U "$ROLE" -d postgres -tAc "SELECT datname FROM pg_database WHERE datname LIKE 'tenant\_%' ESCAPE '\'")
|
||||
for db in $dbs; do
|
||||
psql -h localhost -U "$ROLE" -d postgres -v ON_ERROR_STOP=1 -c "DROP DATABASE IF EXISTS \"${db}\";"
|
||||
done
|
||||
|
||||
echo "Testumgebung zurueckgesetzt: registry-tabelle + $(echo "$dbs" | grep -c . || true) tenant-datenbank(en) entfernt."
|
||||
|
||||
@@ -1,24 +1,12 @@
|
||||
#!/usr/bin/env bash
|
||||
# Ein-Kommando-Pruefung fuer den aktuellen Code-Stand auf dem Testhost:
|
||||
# Registry+Tenant-DBs zuruecksetzen, dann build/vet/test in einem Rutsch.
|
||||
# -p 1 ist Pflicht, da mehrere Pakete dieselbe physische Registry-Tabelle auf
|
||||
# dem Testhost teilen (siehe [[project-nexarch-test-infra]]).
|
||||
#
|
||||
# Aufruf: NEXARCH_TEST_DB_PASSWORD=... ./scripts/run-checks.sh
|
||||
set -euo pipefail
|
||||
|
||||
PASS="${NEXARCH_TEST_DB_PASSWORD:?Setze NEXARCH_TEST_DB_PASSWORD vor dem Aufruf}"
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
NEXARCH_TEST_DB_PASSWORD="$PASS" bash scripts/reset-test-env.sh
|
||||
|
||||
export TEST_ADMIN_DSN="postgresql://nexarch_test:${PASS}@localhost:5432/postgres?sslmode=disable"
|
||||
|
||||
echo "== go build =="
|
||||
go build ./...
|
||||
|
||||
echo "== go vet =="
|
||||
go vet ./...
|
||||
|
||||
echo "== go test (-p 1) =="
|
||||
go test ./... -p 1 -count=1
|
||||
|
||||
Reference in New Issue
Block a user