Compare commits

...

47 commits

Author SHA1 Message Date
Claude (KI)
1bd76bb5ae Apple-Profil-Link: Token als Query-Parameter
Some checks failed
CI / test (push) Has been cancelled
CI / e2e (push) Has been cancelled
Fastify begrenzt Pfadparameter auf 100 Zeichen (FST_ERR_MAX_PARAM_LENGTH, 414);
das Token ist ~140 Zeichen lang.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 11:59:32 +02:00
Claude (KI)
0f7cfc2024 Apple-Profil per https über das Kundencenter (keine Sicherheitswarnung)
KeyHelp liefert setup.mobileconfig nur per http (autoconfig-apple.<domain> ohne Zertifikat).
Die Links zeigen jetzt auf /api/mail-profile/<Token>: HMAC-signiert (KC_SECRET_KEY),
24 h gültig, ohne Anmeldung (QR-Scan). Die API prüft Token, Ressource und Zugehörigkeit über
den Connector, holt das Profil (nur feste KeyHelp-URL-Form, ohne Weiterleitung, max. 256 KB)
und liefert es als application/x-apple-aspen-config aus.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 11:45:47 +02:00
Claude (KI)
fbc4ececd0 Verbindungsdaten schneller: ein KeyHelp-Aufruf statt vier
Postfach und Domains kommen aus /clients/{id}/resources (wie die Liste),
parallel zum Hostnamen, der 1 Stunde zwischengespeichert wird (~1,2 s → ~0,25 s).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 11:44:23 +02:00
Claude (KI)
6a7b5446d5 Postfach: Verbindungsdaten mit Apple-QR-Code wie in KeyHelp
Neuer optionaler Connector-Aufruf children.connectionInfo (nur email, ohne Passwort).
KeyHelp: Server = Hostname des Panels (oder Einstellung mailServer), feste Ports,
Apple-Profil über autoconfig-apple.<Hauptdomain> (Subdomains → Hauptdomain).
API: GET /resources/:id/children/email/:childId/connection (wer Postfächer sieht).
Web: Button „Verbindungsdaten“ je Postfach mit QR-Codes und manuellen Daten.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 11:35:37 +02:00
Claude (KI)
f475e8bd36 Browser-Abnahme: Ticket- und Rechnungsablauf (#119)
Some checks failed
CI / test (push) Has been cancelled
CI / e2e (push) Has been cancelled
- Setup legt feste Ausgangsdaten an (Firmendaten, Testkunde, Rechnungs-
  entwurf) in der Wegwerf-DB kundencenter_e2e.
- Ticket: Kunde eröffnet über die Oberfläche, Personal antwortet, Kunde
  sieht die Antwort (Desktop + 360 px, axe).
- Rechnung: Entwurf für Kunden unsichtbar (404), Personal stellt aus,
  Kunde sieht Nummer und lädt das PDF (axe auf beiden Seiten).
Ergebnis: 15 passed, 1 bewusst übersprungen (Ausstellen nur einmal).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 16:06:41 +02:00
Claude (KI)
bcf188df34 Management-Auswertung: Rolle nur mit analytics.read, lesender MVP (#133)
- Konzept docs/management-auswertung.md: Rechte, Kennzahlen mit
  Definitionen und Quellen, fachlich offene Punkte (nichts erfunden).
- Neue Personalrolle management (Migration 045) mit genau analytics.read;
  niemandem automatisch zugewiesen, vergeben nur durch Superadmin.
- GET /analytics/summary (nur lesend): Kunden/Verträge, Rechnungen
  ausgestellt/Storno/nach Storno, als bezahlt markiert, offen/überfällig,
  nach Steuersatz, Kategorie und Monat; Datenstand, EUR, Definitionen.
- Seite /auswertung mit Zeitraumfilter.
Tests an festen Daten (Storno, 19/7 %, Zeitraumgrenze, Entwurf) und
Rechte-/Schreibweg-Tests. Drift-Test nutzt vorhandene Steuersätze.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 16:01:31 +02:00
Claude (KI)
6c70465e2c KeyHelp: DNS und Verzeichnisschutz lesend, Ausbau zerlegt (#74)
- Neue nur-lesende Unterobjekt-Arten dns und dirprotect: DNS-Einträge der
  Hauptdomains des Kunden (ohne DKIM), Verzeichnisschutz gefiltert auf den
  Kunden (ohne Passwort/Hash). Ändern wird abgewiesen.
- Reiter in der Ressourcenansicht, API-Validierung erweitert.
- docs/connector-keyhelp.md: Teilschritte mit API-Endpunkt und Stand
  (Cronjobs = /scheduled-tasks, Schreibzugriffe erst mit Testkonto #73,
  Fail2Ban/Backups nur Personal).
Tests: Fake um /dns und /directory-protections erweitert, Mandanten-
trennung trotz Leck, keine Geheimnisse in der Ausgabe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 13:36:33 +02:00
Claude (KI)
03cf2b00c4 Öffentliche Statusseite mit Wartungs- und Vorfallverwaltung (#23)
- Modul status (Migration 044): Störungen und Wartungen mit Zustand,
  Auswirkung, Bereich, Zeitraum und Meldungsverlauf. Öffentlich
  (/v1/public/status, Seite /status) nur, was das Personal veröffentlicht –
  nur dessen Texte, keine Kunden-/Ressourcen-/Anbieterdaten, nicht aus den
  internen Betriebsalarmen gespeist. Gesamtzustand aus aktiven Einträgen;
  angekündigte Wartungen zählen erst ab Beginn.
- Verwaltung /admin/status (Support/Admin/Superadmin; Buchhaltung und Kunden
  nicht), Navigation.
- Tests: API (Rechte, Veröffentlichung, Zustände, Abschluss, Felder) und
  Browser (Status- und Registrierungsseite barrierefrei, 12/12 grün).
Passkeys und Berichte bleiben eigene offene Teilaufgaben.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 13:32:19 +02:00
Claude (KI)
17bd9e2817 Bestellung: Domain als eigene Position mit serverseitigem Preis-Snapshot (#80)
- Domain-Preislogik nach @kc/platform/domains verschoben (Domain-Modul und
  Bestellungen nutzen dieselbe Berechnung; Modulgrenzen bleiben sauber).
- POST /orders nimmt domains: [{ name }]: Normalisierung, angebotene
  Endung, kein Doppel, nicht bereits erfasst; Preis/Laufzeit/Einrichtung nur
  aus der Preisliste (Snapshot in order_domains, Migration 043). Ohne
  Verkaufspreis Ablehnung (keine 0-Euro-Domain). Domains → immer Freigabe.
- Bei Freigabe Übernahme in die Domain-Aufstellung (Beschaffung offen,
  Vermerk Bestellnummer), bei Ablehnung nichts. Anzeige in Bestellungen,
  Feld im Bestellformular.
Tests: ungültig, ohne Preis, doppelt, bereits erfasst, Preis-Manipulation
ignoriert, Freigabe/Ablehnung.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 13:25:20 +02:00
Claude (KI)
07d3c01bf4 Selbstregistrierung mit E-Mail-Bestätigung, standardmäßig aus (#36)
- POST /auth/register (nur wenn registration_enabled): Privat-/Geschäfts-
  kunde mit den vorhandenen Fachregeln, Passwort, Datenschutz-Zustimmung,
  Kundengrenze unter Sperre; Antwort immer 202 (keine Auskunft über
  bestehende Konten – diese bekommen nur eine Hinweis-Mail), Rate-Limit.
- POST /auth/verify-email: Einmal-Token (24 h). Freischaltung je
  Einstellung automatisch oder durch Personal (Standard: Personal).
- Verwaltung: Einstellung (Superadmin) + Freigabeliste unter Kunden,
  Freischalten/Ablehnen mit Audit und Mail. Seiten /registrieren und
  /email-bestaetigen, Link auf der Anmeldung nur wenn eingeschaltet.
- Migration 042 (Einstellung, organizations.source, drei Mailvorlagen).
Tests: aus, manuell/auto, Einmal-/Ablauf-Token, Enumeration, Fachregeln,
Kundengrenze. Passkeys bleiben eigene spätere Aufgabe.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 13:20:54 +02:00
Claude (KI)
441341ccef Soll-Ist-Abgleich Vertrag ↔ Anbieter sichtbar machen (#21)
findDrift (platform/drift.ts) vergleicht den Sollzustand aus dem Vertrag
(aktiv/gesperrt/beendet) mit dem zuletzt beobachteten Ressourcenzustand.
Unsichere Beobachtungen (Anbieter gestört, Daten veraltet, unbekannt)
werden als 'ungewiss' statt als Abweichung gemeldet. Nichts wird
automatisch zurückgeschrieben. GET /admin/drift, Dashboard-Karte.
Deterministischer Test mit sechs Fällen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 13:14:23 +02:00
Claude (KI)
f5c689a6ad Kundenangaben an Lizenzen nachziehen und auf Wunsch leeren (#64)
- SDK: optionale Connector-Methode updateCustomerInfo (Capability
  license.customer_info), null = personenbezogene Felder leeren.
- Lizenz-Connector: PUT /licenses/{id} mit customer_name/_contact/_email/
  _reference (Zielwerte, wiederholbar); Herkunftsfelder werden nie gesendet;
  ohne Anbieter-Fähigkeit oder licenses:write klar UNSUPPORTED.
- Auftrag customer.provider_sync: nach Änderung des Kundennamens bzw. Name/
  E-Mail des Inhabers automatisch; Endpunkt + Knöpfe für Abgleich und
  Löschanspruch. Audit nur mit Zählern, keine Personendaten.
Tests: Connector (Werte, Leeren, Ablehnungen), Verdrahtung + Überspringen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 13:11:46 +02:00
Claude (KI)
5dba9f6de2 Lizenz-Connector: Rechte aus Scopes, 403 getrennt, Widerruf, Idempotenz, /ready (#43)
- Service-Token: Schreibfähigkeiten nur gemäß ausdrücklich eingetragenen
  Scopes (neues Verbindungsfeld; ohne Eintrag nur lesend), da das
  Lizenzsystem keine Scope-Introspektion bietet. Benutzer/Passwort wie
  bisher (ohne Widerruf).
- 403 = fehlendes Recht (UNSUPPORTED, kein Re-Login), 401 = Anmeldung.
- terminate → POST /licenses/{id}/revoke (nur mit licenses:revoke).
- Lebenszyklus mit Idempotency-Key kc:<Auftrags-ID>.
- healthCheck über /ready (Fallback /).
Tests: Scope-Teilmengen, nur-lesend, Widerruf/Verlängerung mit Key,
403 vs. 401, Health. 22 Connector-Tests grün.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 13:04:30 +02:00
Claude (KI)
546e667081 Ein-Befehl-Entwicklungsstack mit Mailpit (#14)
ops/dev/run.sh: MariaDB (Volume), Mailpit, API/Worker/Web im Watch-Modus,
Migrationen und idempotente Testdaten (Superadmin, SMTP → Mailpit), nur
Dummy-Konfiguration. Probelauf: Web nach 20 s erreichbar, Login ok,
Passwort-vergessen-Mail kommt in Mailpit an. README ergänzt.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 13:00:57 +02:00
Claude (KI)
ce290143e6 CI: Typecheck, Stilprüfung, Abhängigkeits-Audit; Worker-Tests (#96, #14)
- ci.sh: Stilprüfung (ops/test/check-style.mjs: LF, Schlusszeilenumbruch,
  Leerzeichen am Zeilenende, Tabs, .only/debugger, console.log in
  Bibliotheken/Web – meldet nur, formatiert nichts um), pnpm audit ab high,
  pnpm -r typecheck nach dem Build. 'pnpm check' für lokal.
- Audit-Fund behoben: source-map-js >= 1.2.2 per pnpm-Override (nur
  Testwerkzeuge betroffen).
- Worker-Tests: Job-Runner (Backoff, needs_review nach max_attempts,
  Lease frei) und Discord-Nachrichtenübernahme mit nachgebauten Nachrichten
  (Kunde, Support inkl. Mail mit Antwort-Bezug, Buchhaltung abgewiesen,
  gesperrter Kunde, unbekanntes Konto, geschlossenes Ticket).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:59:12 +02:00
Claude (KI)
7b6a56bb9f Kundengrenze: auch closed → suspended prüfen, Zustand unter Sperre lesen (#116)
Codex-Repro: bei voller Grenze ließ PATCH {status: suspended} einen
beendeten Kunden wieder zählen (200 statt 403), weil nur closed → active
geprüft wurde und der Ausgangszustand vor der Transaktion gelesen wurde.
Jetzt: jeder Wechsel aus closed in einen zählenden Zustand prüft die
Grenze unter der Kapazitätssperre; der aktuelle Zustand wird FOR UPDATE
gelesen. Test: beide Wechsel 403, active↔suspended erlaubt, zwei parallele
Reaktivierungen bei einem freien Platz → genau eine. Ohne Fix rot.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:55:53 +02:00
Claude (KI)
61e8555199 Formularhinweise per aria-describedby an das Eingabefeld binden
Some checks are pending
CI / test (push) Waiting to run
CI / e2e (push) Waiting to run
Field hängte den Hinweistext nur optisch an; Screenreader lasen ihn beim
Fokus nicht vor. Jetzt bekommt das Eingabeelement aria-describedby auf den
Hinweis (WCAG 1.3.1/3.3.2). Doku-Breakpoint auf 800 px korrigiert.
E2E (axe, Desktop/360 px) weiterhin 8/8 grün.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:19:20 +02:00
Claude (KI)
dc54295f9d Designsystem und Seitenlandkarte dokumentiert (#11)
docs/design/README.md: Tokens hell/dunkel aus globals.css, Bausteine aus
ui.tsx, verbindliche Zustände (Laden, leer, Fehler, offline, veraltet,
gesperrt, Betriebsalarm), WCAG-2.2-AA-Regeln mit Verweis auf die
automatische axe-/Tastatur-/360-px-Prüfung (apps/e2e).
docs/design/sitemap.md: alle Seiten (öffentlich, Kunde, Personal), mobile
Navigation, fünf Kernabläufe. FlessingLabs-Stil, keine alte Palette.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:16:00 +02:00
Claude (KI)
7f6c60ba95 Betriebshandbuch an implementierte Dienste angepasst (#12)
- Wiederherstellung: gpg mit Backup-Passwort (age nur für Alt-Sicherungen),
  DEFINER-Bereinigung wie im Restore-Test, Anhänge zurückspielen und gegen
  das Manifest prüfen, Migrationen, Prüfliste nach dem Start.
- Neuer Abschnitt Dienste/Health/Wiederanlauf (Ports, Startreihenfolge,
  Restart-Policies, Health-Endpunkte, Herzschlag, Logs, Timer/Path-Units).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:15:11 +02:00
Claude (KI)
b397c3e3bf Connector-Doku Lizenzsystem aus dem aktuellen Code (#3)
Authentisierung (Service-Token vs. Altweg), Fähigkeitserkennung über
features, alle genutzten Endpunkte mit Zweck, Fehlerabbildung, anonymisiertes
Beispiel der Normalisierung, alte Lückenliste mit heutigem Stand (erledigt /
konkret offen: Service-Token live #60, Scopes→Capabilities #43, Kundendaten-
Sync #64, Source-Abgleich #114).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:14:27 +02:00
Claude (KI)
87e2a2038b Rechnungen: Systemgrenze, Anforderungsmatrix, Rechtsprüfliste; offene Punkte (#5, #26, #49, #13)
- docs/rechnungs-systemgrenze.md: Systemgrenze, Anforderungsmatrix mit
  Belegen (Tests) und offenen Freigaben, Prüfliste Verbraucher/Verträge.
  Benannte Lücken: Leistungsdatum, Reverse-Charge-Hinweis, Archiv/GoBD,
  E-Rechnung, Widerrufsbelehrung, AGB/Datenschutz/Impressum-Links.
  Keine rechtliche Freigabe behauptet.
- ADR 0004 (Eigenbau statt Invoice Ninja), docs/rechnungen.md aktualisiert.
- docs/offene-punkte.md: nur aktuelle Entscheidungen/Zugänge mit
  Verantwortlichem, Abhängigkeit, Abschlusskriterium und Plane-Verweis.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:13:02 +02:00
Claude (KI)
7ece71407b Datenmodell und Statusautomaten dokumentiert (#8)
ER-Diagramm (Mermaid) aus frisch migriertem Schema (Migrationen 001–041,
Fremdschlüssel aus information_schema), Rechnungs-Eigenbau statt
"Rechnungsspiegel" (Snapshots, Storno, Abrechnungsperioden), Übergangs-
tabellen für Bestellung, Vertrag, Rechnung, Ressource, Ticket, Posteingang
und Aufträge mit Verweis auf die Tests der erlaubten/verbotenen Übergänge.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:11:25 +02:00
Claude (KI)
5478f564b8 Sicherheitsdoku: Rollen-/Rechte-Matrix und Bedrohungsmodell (#9, #10)
- docs/sicherheit-und-bedrohungsmodell.md: Personal- und Kundenrechte aus
  dem Code, Impersonation, gleiche Rechte in API und Worker; 20 Bedrohungen
  mit Maßnahme, Modul und Negativtest; offene Punkte (SSRF-Allowlist,
  Passkeys, Modulmatrix).
- Neue Tests (security.test.ts): Impersonation (Rolle, Grund, nur diese
  Organisation, keine Personalrechte, Audit) und Job-Lease nach Absturz.
- Ticket-Anhänge mit X-Content-Type-Options: nosniff.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:09:43 +02:00
Claude (KI)
a0dd7c3940 Architektur-Doku, ADR Job-Queue und automatische Modulgrenzen-Prüfung (#7)
- docs/architektur.md: Prozesse, Pakete und erlaubte Abhängigkeiten,
  API-Module, Mail-Plattform/IMAP, Jobs, Querschnitt, offene Punkte.
- docs/adr/0003-job-queue-in-mariadb.md.
- ops/test/check-boundaries.mjs (ohne neue Abhängigkeit): prüft alle
  Importe gegen die Schichtregeln, inkl. Selbsttest; läuft in ci.sh.
  Gegenprobe: verbotener Modul-Querimport lässt den Lauf scheitern.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:05:59 +02:00
Claude (KI)
9f9c5c4b65 Abrechnungslauf: Entwürfe je Vertragsperiode, genau einmal (#50)
- invoice_billing_periods (PK Vertrag+Periodenbeginn): jede Periode wird
  genau einmal abgerechnet, auch bei parallelen Läufen (INSERT IGNORE in
  der Transaktion). Gelöschter Entwurf gibt die Periode frei (CASCADE),
  Storno hält sie belegt bis zur ausdrücklichen Freigabe
  (POST /invoices/:id/release-periods, Knopf an der stornierten Rechnung).
- Perioden nach Intervall des Preis-Snapshots (monatlich/jährlich, im
  Voraus), nicht über die wirksame Kündigung hinaus; Handrechnungen mit
  contract_id gelten bis zu ihrer Periode als abgerechnet; max. 12 je Lauf.
- Es entstehen nur Entwürfe (je Kunde einer); ausgestellt wird nie
  automatisch. Vorschau + Knopf unter Rechnungen → Fällig; automatischer
  Lauf alle 6 h nur mit Schalter in Einstellungen → Firma (Standard aus).
- Migration 041 (auch invoices.created_by NULL für den automatischen Lauf).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 12:04:01 +02:00
Claude (KI)
9138d5dcb9 Browser-Abnahme mit Playwright und axe (#39, #15)
- apps/e2e: echte API + Web gegen kundencenter_e2e, Superadmin mit 2FA wird
  vorab angelegt. Abläufe: Login-Seite (Tastatur, falsches Passwort),
  Personal-Login mit 2FA + Abmelden (Sitzung beendet, geschützte Seite
  leitet um), Kundenanlage → Einladung → Kundenlogin, Mandantentrennung
  (fremde Organisation/Mitglieder 403/404, Verwaltung 401/403), 2FA-Replay.
- Projekte: Desktop hell und 360 px dunkel (touch); axe nach WCAG 2.2 AA auf
  Login, Dashboard, Kundenliste, Kunden-Dashboard – schwere/kritische
  Verstöße = rot. Lokal: 8/8 grün.
- ops/test/run-e2e.sh (Playwright-Image) und zweiter CI-Job.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 11:57:20 +02:00
Claude (KI)
e9836f0efd Betriebsalarme mit Entwarnung: Lizenzserver, Warteschlange, Worker-Ausfall (#20, #38)
- system_alerts: Zustand je Alarm, Meldung nach Karenzzeit genau einmal,
  Entwarnung nur nach vorheriger Meldung; aktive Alarme im Dashboard.
- Lizenzprüfung unterscheidet config/outage/rejected; Ausfall wird alle
  10 min wiederholt und nach 30 min gemeldet, Konfigurations-/Ablehnungs-
  fehler und ungültige Lizenz sofort; Testmodus ohne Schlüssel bleibt still.
- Worker meldet Warteschlangen-Stau und needs_review per Discord.
- Worker-Herzschlag; die API meldet einen ausgefallenen Worker per Mail an
  die Superadmins (Discord läuft im Worker).
- Migration 040, Doku-Tabelle in betrieb-backup-restore.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 11:35:02 +02:00
Claude (KI)
8eb8c54aab Testumgebung und CI: ein Befehl mit Docker, Forgejo-Workflow (#96, #14)
- ops/test/run.sh: Compose mit Wegwerf-MariaDB (tmpfs) und Test-Image
  (Node 24, pnpm, mysqldump/gpg/age/rclone), Dummy-Schlüssel.
- ops/test/ci.sh: install --frozen-lockfile → build → Plattform-,
  Connector- und API-Tests; bricht beim ersten Fehler ab.
- .forgejo/workflows/ci.yml: gleicher Ablauf, braucht einen Runner (docker).
- API-Tests löschen kundencenter_test nur mit KC_TEST_DB_RESET=1.

Lokal verifiziert: 154 Tests grün.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 11:30:52 +02:00
Claude (KI)
677186e3f3 Discord: zentrale Ticket-Rechte, Kanalzugriffe abgleichen, Nummern atomar (#110)
- Ticket-Rechte je Rolle in @kc/platform/ticketPolicy, vom Tickets-Modul UND
  vom Discord-Worker genutzt. Buchhaltung (nur lesen) kann über Discord kein
  Ticket mehr anlegen, beantworten, zuweisen oder schließen.
- Kundenzugriff auf Ticket-Kanäle wird bei jedem Abgleich synchronisiert:
  Freigaben entknüpfter/deaktivierter Konten, ausgetretener Mitglieder und
  gesperrter Kunden werden entfernt.
- Nachrichten deaktivierter Kunden-Konten oder gesperrter Kunden werden nicht
  übernommen; /ticket nur für aktive Organisationen.
- Ticketnummer + Ticket + erste Nachricht in einer Transaktion auf einer
  Verbindung (vorher LAST_INSERT_ID über den Pool).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 11:28:01 +02:00
Claude (KI)
914599df50 IMAP-Posteingang: Zuordnung nur mit signiertem Antwort-Bezug, Wiederholung, Dubletten (#107)
- Absender (From) und Ticketnummer im Betreff sind fälschbar und ordnen nicht
  mehr automatisch zu. Ausgehende Ticket-Mails tragen eine Message-ID mit
  Ticket-ID + HMAC (KC_SECRET_KEY); nur Antworten mit gültigem Bezug in
  In-Reply-To/References von einem aktiven Mitglied des aktiven Kunden
  werden angehängt. Alles andere: Posteingang mit vorausgefülltem Vorschlag.
- Fehler einer UID: last_uid bleibt davor stehen, bis zu 5 Wiederholungen,
  danach als nicht verarbeitbar im Posteingang abgelegt (Mail geht nicht
  verloren). UIDVALIDITY wird gespeichert; Wechsel = neuer Startpunkt.
- Verarbeitung je Nachricht in einer Transaktion; Dubletten-Schutz per
  UNIQUE(uid_validity, uid); Ticketnummern über dieselbe Verbindung.
- Posteingang zuweisen/anhängen/ignorieren atomar (kein Doppel-Ticket).
- Migration 039.

Hinweis: neue Mails bekannter Kunden ohne Bezug legen kein Ticket mehr
automatisch an, sondern warten im Posteingang (Vorschlag vorausgefüllt).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 11:24:36 +02:00
Claude (KI)
7a5f0b6d24 Lizenz: Grenzen bis zum Commit sperren, Signatur verpflichtend (#116)
- Kunden-/Personalgrenze: Zeilensperre auf license_state in der Transaktion
  der Anlage statt GET_LOCK (wurde vor INSERT/COMMIT freigegeben, Ergebnis
  nicht geprüft). Personal-Anlage, Reaktivierung und CLI-Superadmin laufen
  jetzt ebenfalls atomar gegen die Grenze.
- /license/verify: Antwort ohne Signatur wird abgewiesen; übernommen werden
  nur Werte aus dem geprüften FLS1-Payload (typ, licenseKey, instanceId
  abgeglichen). Serverzeit muss aktuell (±15 min) und nicht älter als die
  zuletzt akzeptierte sein (Replay). Widerrufene Schlüssel zählen nicht.
- setTestEdition() für Tests (nur KC_NODE_ENV=test).

Offen (Entscheidung #113): Modulmatrix billing/domains/provisioning/automation.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 11:18:45 +02:00
Claude (KI)
8ee2eecde8 Migrationen: Sperre auf eigener Verbindung, Wiederanlauf nach Abbruch (#100)
GET_LOCK/RELEASE_LOCK liefen über den Pool und damit ggf. auf verschiedenen
Sitzungen; die Sperre schützte DDL nicht zuverlässig und wurde evtl. nie
freigegeben. Jetzt nutzt der gesamte Lauf eine Verbindung.

Fortschritt je Migration in schema_migrations_dirty: nach einem Abbruch
verweigern weitere Läufe die Arbeit, bis mit --resume ab der
fehlgeschlagenen Anweisung fortgesetzt wird (Prüfsumme muss gleich sein).
Tests: parallele Läufe, Sperre nach Fehler frei, Abbruch + Resume.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 11:15:06 +02:00
Claude (KI)
ce71058b4d CSV-Export: Formelanfänge auch in der Domain-Aufstellung neutralisieren (#77)
Der Browser-Export der Domain-Aufstellung quotierte nur Anführungszeichen;
Kundennamen/Notizen mit führendem =,+,-,@ wurden in Excel als Formel
ausgeführt. Gemeinsame Regel in @kc/platform/csv (auch CR), von Audit- und
Rechnungsexport genutzt; Web nutzt dieselbe Regel für Textzellen, Beträge
bleiben Zahlen.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 11:13:51 +02:00
Claude (KI)
2af4beb8e2 Rechnungen: Positionen nur unter Zeilensperre ersetzen (#95)
PUT /invoices/:id/items prüfte den Entwurfsstatus außerhalb der Transaktion.
Ein paralleles Ausstellen konnte dazwischen gewinnen; danach ersetzte das
Speichern die Positionen einer bereits offenen Rechnung. Jetzt wird die
Rechnungszeile wie beim Ausstellen per FOR UPDATE gesperrt und der Status
erst dort geprüft. Ausstellen prüft die Positionen ebenfalls unter der
Sperre und meldet die Summe aus dem gesperrten Stand.

Tests: deterministischer Save-vs-Issue-Test (409, Positionen unverändert)
und paralleler Wiederholungstest (Summe = Positionen).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-06 11:11:55 +02:00
Kundencenter
119a4fe07e Plesk: Domains, Postfächer, Datenbanken und FTP anlegen, ändern, löschen
- Unterobjekte schreibbar (children.write): Sites/Subdomains anlegen und
  löschen (Hauptdomain geschützt), Postfächer (anlegen, Passwort, Größe,
  löschen), MySQL-Datenbanken mit Benutzer (anlegen, Passwort, löschen),
  FTP-Benutzer (anlegen, Passwort/Verzeichnis, löschen)
- Mandantentrennung: vor jeder Änderung Zugehörigkeit zum Abonnement prüfen;
  Anlegen wiederholbar, Löschen idempotent
- Live an Plesk 18.0.81 geprüft; Eigenheiten berücksichtigt: set-db-user mit
  <id>, create-non-existent, Fehler 1024 (Limit) = Ablehnung statt Retry,
  Teilanlage von Postfächern bei Größenfehler wird zurückgerollt
- Nachbau verhält sich entsprechend; 5 neue Tests (22 gesamt)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 21:35:11 +02:00
Kundencenter
612ab5fc53 Plesk-Connector: Korrekturen aus dem Live-Test (Plesk 18.0.81)
- Health: server/get mit gen_info vor stat (Plesk lehnte die Reihenfolge ab)
- Panel-Login: Plesk bindet die Sitzung an user_ip; die API übergibt jetzt
  die IP des Browsers (SDK loginUrl(ctx, ref, { userIp }), clientIp(req)),
  ohne IP gibt es eine klare Fehlermeldung statt eines toten Links
- Unterobjekte: leeres Ergebnis ohne id bei Datenbanken/FTP wird ausgefiltert
- Nachbau verhält sich jetzt wie das echte Plesk (Reihenfolge, IP-Bindung,
  leere Ergebnisse); Live-Prüfung in docs/connector-plesk.md dokumentiert

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 21:15:20 +02:00
Kundencenter
2aa793ed05 Plesk-Connector (XML-API): Abgleich, Kundenübernahme, Bereitstellung, Panel-Login
- Neues Paket @kc/connector-plesk: ein Plesk-Abonnement = ein Hosting-Konto,
  Kontaktdaten vom Plesk-Kunden; Service-Pläne als Produktvorlagen
- Abgleich mit Besitzer, Plan, Limits, Nutzung und Ablauf; Kundenübernahme
- Bereitstellung: Kunde (Login kc+Vertragsnummer, Vermerk) und Abonnement
  kc<Nr>.<Domain> auf dem Plan, sichere Wiederholung ohne Doppelanlage;
  Passwörter werden nie gespeichert
- Sperren/Entsperren, Planwechsel, Löschen (nie automatisch wiederholt),
  Passwort des Besitzers, Panel-Login als Einmal-Sitzung
- Unterobjekte (Domains, Postfächer, Datenbanken, FTP) nur lesend
- Eigener kleiner XML-Baustein: Werte maskiert, DOCTYPE/ENTITY abgelehnt
- 17 Tests gegen einen Plesk-Nachbau (test/fake.ts); NICHT gegen eine echte
  Instanz geprüft – Annahmen in docs/connector-plesk.md
- Verbindungen: Einrichtungshinweis für Plesk; Domain-Übernahme-Text neutral

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 17:37:04 +02:00
Kundencenter
672aa5ad89 Übersicht: „Hosting und Lizenzen“ statt „Ressourcen und Lizenzen“
- Kachel auf der Kunden-Übersicht und Überschrift auf der Kundendetailseite
  umbenannt (dieselbe Gruppierung wie auf der Ressourcen-Seite)
- Aufteilung unter der Zahl, z. B. „2 Webhosting · 1 Lizenz“

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 17:37:04 +02:00
Kundencenter
cce13d029b Domain-Aufstellung in voller Breite
- Seiten mit .page-wide nutzen bis 1800 px statt 1280 px Breite; die
  Domain-Aufstellung passt so auf 1920er-Bildschirmen ohne seitliches Scrollen
- Status-Auswahl mit Mindestbreite (war abgeschnitten), Aktionen untereinander
  statt nebeneinander, Buttons ohne Zeilenumbruch
- Handy-Karten: Unterzeilen (Kundennummer, „inkl. USt“) stehen unter dem Wert
  statt in der Beschriftungsspalte; Summenzeile lesbar

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 16:15:32 +02:00
Kundencenter
8e77cf0523 Datumsanzeige, Handy-Tabellen als Karten, Übersicht mit Kurzlisten
- Reine Datumsangaben ohne Uhrzeit: fmtDay für SQL-DATE-Spalten (Rechnungs-
  und Fälligkeitsdatum kamen als UTC-Mitternacht und zeigten „02:00“),
  fmtDate für Laufzeitende, Kündigungsdatum und Gültigkeit
- Tabellen werden auf schmalen Bildschirmen zu Karten; TableCards beschriftet
  die Zellen automatisch mit ihrer Spaltenüberschrift (alle Tabellen, ohne
  Änderung der einzelnen Seiten)
- Übersicht: „Aktuelle Tickets“ und „Offene Rechnungen“ (überfällige zuerst)
  für Personal und Kunden
- Buttons erben die Schrift (Kennzahl-Kacheln auf /lizenzen zeigten die
  Systemschrift); Checkboxen und Radios in Markenfarbe mit fester Größe

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 15:11:40 +02:00
Kundencenter
277d038669 Design an flessinglabs.com angelehnt
- Schrift Geist / Geist Mono (wie flessinglabs.com) statt Inter
- Dunkelmodus mit den Website-Farben (#05060a / #0b0d14 / #121622, Ränder
  weiß 8 %, Text #f5f7ff, gedämpft #9aa4b5)
- Seitenleiste immer im FlessingLabs-Dunkel mit blauem Lichtschein
- Primärbuttons, Avatar und Akzentleiste im Markenverlauf Cyan → Blau →
  Violett; Buttonverlauf abgedunkelt, damit weißer Text >= 4,5:1 erreicht
- Anmeldeseiten mit Gitter und Lichtschein wie die Website-Startseite
- Radien 10/12/16 px wie auf der Website

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 14:00:16 +02:00
Kundencenter
6dc54786fa FlessingLabs-Logo als Markenzeichen und Favicon
- FL-Zeichen aus flessinglabs.com/logo-dark.png freigestellt (transparent,
  128 px), ersetzt das KC-Zeichen in Seitenleiste, mobiler Kopfzeile und auf
  den Anmeldeseiten
- favicon.ico, icon.png und apple-icon.png (Zeichen auf dunklem Quadrat)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 14:00:16 +02:00
Kundencenter
f3e89554f4 Oberfläche modernisiert, Herstellerhinweis FlessingLabs
- Navigation mit Icons, Akzentleiste am aktiven Eintrag, Chevron statt Zeichen,
  Benutzerblock mit Initialen, dezente Buttons in der Seitenleiste
- Markenzeichen „KC“ (Seitenleiste, mobile Kopfzeile, Anmeldeseiten)
- Fußzeile „KC@FlessingLabs · © FlessingLabs · flessinglabs.com“ in der App
  und auf allen Seiten außerhalb der Anmeldung
- Behoben: Seite lief auf dem Handy bei breiten Tabellen seitlich über
  (Rasterspalte minmax(0, 1fr)); Kennungen in Tabellen und Badges brechen
  nicht mehr um; doppelter Abstand zwischen Übersichtskarten
- Links dezenter unterstrichen, in Tabellen erst beim Überfahren

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 13:51:51 +02:00
Kundencenter
e0f2141901 Oberfläche: Kontraste nach WCAG, SVG-Icons statt Emojis
- Hellmodus: Status-/Hinweisfarben (ok/info/warn/err) und Akzent auf >= 4,5:1
  angehoben, aktiver Eintrag der mobilen Navigation nutzt den Akzent statt Türkis
- Eingabefelder und Textbereiche mit Rand >= 3:1 (--border-strong), Textbereiche
  einheitlich gestylt
- Icon-Komponente (Lucide-Pfade) ersetzt Emojis im Darstellungsumschalter,
  Kundenansicht-Banner und bei Ticket-Anhängen; mobile Navigation mit Icons
- Kundenansicht-Banner über Tokens statt fester Farben; Bildanhänge lazy laden

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 13:41:48 +02:00
Kundencenter
9d2232308c Benutzer ändern: Prüfungen vor dem Schreiben der E-Mail
Bisher wurde die neue Anmelde-E-Mail (samt Entwertung der Tokens und
Sitzungen) geschrieben, bevor staffRole/Status geprüft wurden. Schlug
eine dieser Prüfungen fehl, blieb die E-Mail ohne Audit-Eintrag geändert.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 13:11:40 +02:00
Claude
9ad687b90b Wiederherstellungstest: DEFINER aus Dump entfernen, EPIPE abfangen
Trigger aus Migration 033 tragen den DEFINER des Import-Nutzers (phpMyAdmin
von KeyHelp); ohne SET USER schlägt der Import in die Test-DB fehl. Zusätzlich
stürzte run() bei frühem Abbruch von mysql mit unbehandeltem EPIPE ab und
verschluckte die eigentliche Fehlermeldung.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 12:57:16 +02:00
Kundencenter
fb3a2ebf73 Allow staff to change a user's login email and name
PATCH /admin/users/:id now accepts email and name. Changing the email
invalidates open invite/reset links (they went to the old address) and
ends existing sessions; duplicates are rejected, staff login emails can
only be changed by a superadmin, and the old values go to the audit log.
The customer page gets an edit form per user, optionally updating the
billing email along with it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-05 10:44:15 +02:00
155 changed files with 5522 additions and 567 deletions

56
.forgejo/workflows/ci.yml Normal file
View file

@ -0,0 +1,56 @@
# CI für Forgejo Actions (#96). Läuft, sobald für die Forge ein Runner mit Label "docker" registriert ist.
# Gleicher Ablauf wie lokal mit ops/test/run.sh; rote Tests lassen den Lauf fehlschlagen.
name: CI
on:
push: { branches: [main] }
pull_request:
jobs:
test:
runs-on: docker
container: { image: node:24-bookworm }
services:
db:
image: mariadb:11.4
env: { MARIADB_ROOT_PASSWORD: testroot }
options: --health-cmd="healthcheck.sh --connect --innodb_initialized" --health-interval=2s --health-retries=30
env:
CI: "1"
KC_ENV_DIR: /nonexistent
KC_TEST_DB_RESET: "1"
DB_HOST: db
DB_PORT: "3306"
DB_NAME: kundencenter_test
DB_USER: root
DB_PASSWORD: testroot
KC_SECRET_KEY: dGVzdC1zY2hsdWVzc2VsLW51ci1mdWVyLWNpLTMyLWI=
LICENSE_PROGRAM_KEY: 00000000-0000-0000-0000-000000000000
steps:
- uses: https://code.forgejo.org/actions/checkout@v4
- name: Werkzeuge (mysqldump, gpg, age, rclone)
run: apt-get update && apt-get install -y --no-install-recommends mariadb-client gnupg age rclone openssh-client && corepack enable && corepack prepare pnpm@10.14.0 --activate
- name: Installieren, bauen, testen
run: bash ops/test/ci.sh
e2e:
# Browser-Abnahme (#39): Login/2FA, Kundenanlage → Einladung → Kundenlogin, Mandantentrennung, Tastatur,
# Desktop/360 px, Hell/Dunkel, axe (WCAG 2.2 AA, schwere/kritische Verstöße = rot).
runs-on: docker
container: { image: "mcr.microsoft.com/playwright:v1.63.0-noble" }
services:
db:
image: mariadb:11.4
env: { MARIADB_ROOT_PASSWORD: testroot }
options: --health-cmd="healthcheck.sh --connect --innodb_initialized" --health-interval=2s --health-retries=30
env:
CI: "1"
KC_ENV_DIR: /nonexistent
KC_TEST_DB_RESET: "1"
DB_HOST: db
DB_PORT: "3306"
DB_USER: root
DB_PASSWORD: testroot
KC_SECRET_KEY: dGVzdC1zY2hsdWVzc2VsLW51ci1mdWVyLWNpLTMyLWI=
LICENSE_PROGRAM_KEY: 00000000-0000-0000-0000-000000000000
steps:
- uses: https://code.forgejo.org/actions/checkout@v4
- name: Installieren, bauen, Browser-Tests
run: corepack enable && corepack prepare pnpm@10.14.0 --activate && pnpm install --frozen-lockfile && pnpm build && cd apps/e2e && pnpm e2e

2
.gitignore vendored
View file

@ -7,3 +7,5 @@ dist
*.log
*.tsbuildinfo
.pnpm-store/
apps/e2e/test-results/
apps/e2e/playwright-report/

View file

@ -101,6 +101,37 @@ API-Module liegen in `apps/api/src/modules/<name>` und implementieren `KcModule`
`modules/index.ts` eingetragen, registrieren Routen und Rechte und sprechen nur über `core/*` und Jobs miteinander.
Neue Anbieter kommen als Connector unter `packages/connector-*` hinzu (`docs/connector-vertrag.md`).
## Lokale Entwicklung
Ein Befehl, nur Docker nötig:
```bash
ops/dev/run.sh
```
Startet MariaDB (eigenes Volume), Mailpit und API/Worker/Web im Watch-Modus mit Dummy-Konfiguration (`ops/dev/dev.env`).
Kundencenter: http://127.0.0.1:4101 (Anmeldung `dev@kundencenter.local` / `entwicklung-passwort-123`, 2FA wird beim ersten
Login eingerichtet), ausgehende Mails: http://127.0.0.1:8025. Zurücksetzen: `docker compose -f ops/dev/compose.yml down -v`.
Vor dem Commit: `pnpm check` (Modulgrenzen + Stilprüfung).
## Tests
`cd apps/api && pnpm test` – Integrationstests gegen eine **separate** Datenbank `kundencenter_test` (wird bei jedem Lauf
neu erstellt). Abgedeckt: Login, Sperre, CSRF, 2FA-Pflicht, Sitzungen, Kundenanlage, Mandantentrennung, Rechte, Audit-Kette.
Ein Befehl, nur Docker nötig (frischer Checkout, Dummy-Schlüssel, Wegwerf-MariaDB im RAM – nie die Produktivdatenbank):
```bash
ops/test/run.sh
```
Ablauf (`ops/test/ci.sh`, identisch in der CI unter `.forgejo/workflows/ci.yml`): `pnpm install --frozen-lockfile` →
`pnpm build` (vor den Tests, weil die Pakete über `dist/` aufgelöst werden) → Plattform-, Connector- und API-Tests.
Die API-Integrationstests legen die Datenbank `kundencenter_test` bei jedem Lauf neu an und starten nur mit
`KC_TEST_DB_RESET=1` (in der Testumgebung gesetzt) – auf einem Produktivhost brechen sie daher sofort ab.
Abgedeckt u. a.: Login, Sperre, CSRF, 2FA-Pflicht, Sitzungen, Kundenanlage, Mandantentrennung, Rechte, Audit-Kette,
Rechnungen (inkl. Nebenläufigkeit), Migrationen (Sperre/Wiederanlauf), Lizenzgrenzen und -signatur, IMAP-Zuordnung.
Browser-Abnahme (Playwright + axe, eigenes Image mit Chromium):
```bash
ops/test/run-e2e.sh
```
Startet API und Web gegen die Wegwerf-Datenbank `kundencenter_e2e` und prüft Login mit 2FA (inkl. Replay-Schutz),
Kundenanlage → Einladung → Kundenlogin, Mandantentrennung, Tastaturbedienung, Desktop und 360 px, Hell und Dunkel sowie
WCAG 2.2 AA per axe (schwere/kritische Verstöße lassen den Lauf scheitern). Noch offen: Worker-Tests mit echtem IMAP/Discord.

View file

@ -1,7 +1,7 @@
import { randomUUID } from 'node:crypto';
import { hash } from '@node-rs/argon2';
import '../core/config.js';
import { pool, one, run } from '../core/db.js';
import { pool, one, run, tx } from '../core/db.js';
import { audit } from '../core/audit.js';
import { assertStaffCapacity } from '../core/license.js';
@ -42,12 +42,18 @@ if (cmd === 'create-superadmin') {
const email = opt('email')?.toLowerCase(), name = opt('name') ?? 'Superadmin';
if (!email) { console.error('Nutzung: create-superadmin --email=… [--name=…] (Passwort wird danach abgefragt, nie als Argument)'); process.exit(2); }
if (await one('SELECT 1 AS x FROM users WHERE email = ?', [email])) { console.error('E-Mail existiert bereits (für einen Reset stattdessen: reset-password --email=…)'); process.exit(1); }
const cap = await assertStaffCapacity();
if (!cap.allowed) { console.error(cap.reason); process.exit(1); }
const pre = await tx((c) => assertStaffCapacity(c)); // frühe Meldung, bevor nach dem Passwort gefragt wird
if (!pre.allowed) { console.error(pre.reason); process.exit(1); }
const pw = await readPassword().catch((e) => { console.error((e as Error).message); process.exit(1); });
if (pw.length < 12) { console.error('Passwort zu kurz (min. 12 Zeichen)'); process.exit(2); }
const id = randomUUID();
await run("INSERT INTO users (id, email, name, password_hash, kind, staff_role, status, email_verified_at) VALUES (?,?,?,?,'staff','superadmin','active',UTC_TIMESTAMP(3))", [id, email, name, await hash(pw, ARGON)]);
const pwHash = await hash(pw, ARGON);
const cap = await tx(async (c) => {
const r = await assertStaffCapacity(c); // erneut unter Sperre bis zum Commit
if (r.allowed) await run("INSERT INTO users (id, email, name, password_hash, kind, staff_role, status, email_verified_at) VALUES (?,?,?,?,'staff','superadmin','active',UTC_TIMESTAMP(3))", [id, email, name, pwHash], c);
return r;
});
if (!cap.allowed) { console.error(cap.reason); process.exit(1); }
await audit({ actorType: 'system', action: 'user.create', resourceType: 'user', resourceId: id, after: { email, kind: 'staff', staffRole: 'superadmin', via: 'cli' } });
console.log('Superadmin angelegt:', email, '(2FA muss beim ersten Login eingerichtet werden)');
} else if (cmd === 'reset-password') {

View file

@ -2,47 +2,98 @@ import { createHash } from 'node:crypto';
import { readdirSync, readFileSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { join, dirname } from 'node:path';
import type { PoolConnection } from 'mysql2/promise';
import '../core/config.js';
import { pool } from '../core/db.js';
const dir = join(dirname(fileURLToPath(import.meta.url)), '../../../../migrations');
const defaultDir = join(dirname(fileURLToPath(import.meta.url)), '../../../../migrations');
const sha256 = (s: string) => createHash('sha256').update(s).digest('hex');
export const splitStatements = (content: string) => content.replace(/^\s*--.*$/gm, '').split(/;\s*\n/).map((s) => s.trim()).filter(Boolean);
export async function migrate(): Promise<void> {
await pool.query('CREATE TABLE IF NOT EXISTS schema_migrations (name VARCHAR(200) PRIMARY KEY, checksum CHAR(64) NULL, applied_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3))');
await pool.query('ALTER TABLE schema_migrations ADD COLUMN IF NOT EXISTS checksum CHAR(64) NULL'); // bestehende Installationen ohne die Spalte nachziehen
// Sperre gegen gleichzeitige Migrationsläufe (z. B. zwei parallele Deploys) – sonst könnten beide dieselbe neue
// Migration anwenden oder sich beim Anlegen der Zeile in schema_migrations in die Quere kommen.
const [[lockRow]] = await pool.query('SELECT GET_LOCK(?, 10) AS got', ['kc_migrate']) as any;
if (Number(lockRow?.got) !== 1) throw new Error('Migrations-Sperre konnte nicht erlangt werden (läuft bereits eine andere Migration? Zeitüberschreitung nach 10s)');
export interface MigrateOptions {
/** Verzeichnis mit *.sql (Tests). */
dir?: string;
/** Eine abgebrochene Migration nach Prüfung ab der ersten nicht angewendeten Anweisung fortsetzen. */
resume?: boolean;
/** Wartezeit auf die Sperre in Sekunden. */
lockTimeoutSec?: number;
}
/**
* Wendet neue Migrationen an. Alles läuft über EINE Verbindung: GET_LOCK ist in MariaDB an die Sitzung gebunden –
* über den Pool könnten Sperre, DDL und RELEASE_LOCK auf verschiedenen Verbindungen landen (Sperre schützt dann nichts
* bzw. wird nie freigegeben).
*
* DDL ist in MariaDB nicht transaktional. Deshalb wird je Migration der Fortschritt (angewendete Anweisungen) in
* schema_migrations_dirty mitgeschrieben. Bricht eine Migration ab, verweigern weitere Läufe die Arbeit, bis jemand
* den Zustand geprüft hat: `pnpm migrate --resume` setzt bei der fehlgeschlagenen Anweisung fort (die davor sind
* bereits angewendet und werden nicht wiederholt). Siehe docs/betrieb-backup-restore.md, Abschnitt Migrationen.
*/
export async function migrate(opts: MigrateOptions = {}): Promise<string[]> {
const dir = opts.dir ?? defaultDir;
const done: string[] = [];
const c: PoolConnection = await pool.getConnection();
let locked = false;
try {
const rows = (await pool.query('SELECT name, checksum FROM schema_migrations') as any)[0] as { name: string; checksum: string | null }[];
await c.query('CREATE TABLE IF NOT EXISTS schema_migrations (name VARCHAR(200) PRIMARY KEY, checksum CHAR(64) NULL, applied_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3))');
await c.query('ALTER TABLE schema_migrations ADD COLUMN IF NOT EXISTS checksum CHAR(64) NULL'); // bestehende Installationen ohne die Spalte nachziehen
await c.query('CREATE TABLE IF NOT EXISTS schema_migrations_dirty (name VARCHAR(200) PRIMARY KEY, checksum CHAR(64) NOT NULL, statements_done INT NOT NULL, statements_total INT NOT NULL, error TEXT NULL, updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3))');
// Sperre gegen gleichzeitige Migrationsläufe (z. B. zwei parallele Deploys).
const [[lockRow]] = await c.query('SELECT GET_LOCK(?, ?) AS got', ['kc_migrate', opts.lockTimeoutSec ?? 10]) as any;
if (Number(lockRow?.got) !== 1) throw new Error('Migrations-Sperre konnte nicht erlangt werden (läuft bereits eine andere Migration? Zeitüberschreitung)');
locked = true;
const dirty = ((await c.query('SELECT * FROM schema_migrations_dirty') as any)[0]) as { name: string; checksum: string; statements_done: number; statements_total: number; error: string | null }[];
if (dirty.length > 0 && !opts.resume) {
const d = dirty[0]!;
throw new Error(`Migration ${d.name} ist unvollständig: ${d.statements_done} von ${d.statements_total} Anweisungen angewendet` +
(d.error ? `, Fehler: ${d.error}` : ' (Abbruch)') + '. Zustand der Datenbank prüfen, Ursache beheben, dann mit "pnpm migrate --resume" fortsetzen.');
}
const resumeAt = new Map(dirty.map((d) => [d.name, d]));
const rows = (await c.query('SELECT name, checksum FROM schema_migrations') as any)[0] as { name: string; checksum: string | null }[];
const applied = new Map(rows.map((r) => [r.name, r.checksum]));
for (const f of readdirSync(dir).filter((n) => n.endsWith('.sql')).sort()) {
const content = readFileSync(join(dir, f), 'utf8');
const sum = sha256(content);
if (applied.has(f)) {
const stored = applied.get(f);
// Bereits angewendete Migrationen dürfen nachträglich nicht mehr verändert werden (sonst driften Umgebungen
// unbemerkt auseinander, je nachdem wann sie migriert haben). Alte Zeilen ohne Prüfsumme werden einmalig nachgetragen.
if (stored == null) await pool.query('UPDATE schema_migrations SET checksum = ? WHERE name = ?', [sum, f]);
// Bereits angewendete Migrationen dürfen nachträglich nicht mehr verändert werden. Alte Zeilen ohne Prüfsumme werden einmalig nachgetragen.
if (stored == null) await c.query('UPDATE schema_migrations SET checksum = ? WHERE name = ?', [sum, f]);
else if (stored !== sum) throw new Error(`Migration ${f} wurde bereits angewendet, ihr Inhalt hat sich seitdem aber geändert (Prüfsumme weicht ab). Bitte die Datei nicht nachträglich bearbeiten, sondern eine neue Migration anlegen.`);
continue;
}
const c = await pool.getConnection();
try {
// DDL ist in MariaDB nicht transaktional; jede Migration einzeln, bei Fehler Abbruch.
const stmts = content.replace(/^\s*--.*$/gm, '').split(/;\s*\n/).map((s) => s.trim()).filter(Boolean);
for (const st of stmts) await c.query(st);
await c.query('INSERT INTO schema_migrations (name, checksum) VALUES (?, ?)', [f, sum]);
console.log('migriert:', f);
} finally { c.release(); }
const stmts = splitStatements(content);
let start = 0;
const prev = resumeAt.get(f);
if (prev) {
if (prev.checksum !== sum) throw new Error(`Migration ${f} wurde seit dem Abbruch verändert – Fortsetzen ist nicht sicher. Ursprüngliche Datei wiederherstellen oder den Zustand von Hand bereinigen.`);
start = prev.statements_done;
console.log(`setze ${f} bei Anweisung ${start + 1} von ${stmts.length} fort`);
} else {
await c.query('INSERT INTO schema_migrations_dirty (name, checksum, statements_done, statements_total) VALUES (?, ?, 0, ?)', [f, sum, stmts.length]);
}
for (let i = start; i < stmts.length; i++) {
try {
await c.query(stmts[i]!);
} catch (e) {
await c.query('UPDATE schema_migrations_dirty SET error = ? WHERE name = ?', [String((e as Error).message).slice(0, 2000), f]).catch(() => undefined);
throw new Error(`Migration ${f}, Anweisung ${i + 1} von ${stmts.length} fehlgeschlagen: ${(e as Error).message}`);
}
await c.query('UPDATE schema_migrations_dirty SET statements_done = ?, error = NULL WHERE name = ?', [i + 1, f]);
}
await c.query('INSERT INTO schema_migrations (name, checksum) VALUES (?, ?)', [f, sum]);
await c.query('DELETE FROM schema_migrations_dirty WHERE name = ?', [f]);
done.push(f);
console.log('migriert:', f);
}
return done;
} finally {
await pool.query('SELECT RELEASE_LOCK(?)', ['kc_migrate']).catch(() => undefined);
if (locked) await c.query('SELECT RELEASE_LOCK(?)', ['kc_migrate']).catch(() => undefined);
c.release();
}
}
if (import.meta.url === `file://${process.argv[1]}`) {
try { await migrate(); } catch (e) { console.error((e as Error).message); await pool.end(); process.exit(1); }
try { await migrate({ resume: process.argv.includes('--resume') }); } catch (e) { console.error((e as Error).message); await pool.end(); process.exit(1); }
await pool.end();
}

View file

@ -15,7 +15,7 @@ export async function createInvitedUser(c: PoolConnection, u: { email: string; n
}
export async function createToken(c: PoolConnection | undefined, userId: string, purpose: 'invite' | 'password_reset' | 'verify_email'): Promise<string> {
const token = randomToken(32);
const hours = purpose === 'invite' ? INVITE_DAYS * 24 : 1;
const hours = purpose === 'invite' ? INVITE_DAYS * 24 : purpose === 'verify_email' ? 24 : 1;
await run('INSERT INTO user_tokens (id, user_id, purpose, token_hash, expires_at) VALUES (?,?,?,?, DATE_ADD(UTC_TIMESTAMP(3), INTERVAL ? HOUR))', [randomUUID(), userId, purpose, sha256(token), hours], c);
return token;
}
@ -25,3 +25,5 @@ export const resetLink = (token: string): string => `${config.baseUrl}/passwort-
export async function mailInvite(email: string, name: string, token: string): Promise<string> {
return sendTemplateMail(email, 'invite', { name, inviteLink: inviteLink(token), validDays: String(INVITE_DAYS) });
}
/** Argon2id-Parameter für Passwörter (gleich in Anmeldung, Einladung, Registrierung). */
export const ARGON = { memoryCost: 19456, timeCost: 2, parallelism: 1 };

View file

@ -1,5 +1,6 @@
/** Zentrale Policy-Schicht: RBAC (Staff-Rollen, Org-Rollen) + objektbezogene Prüfung. */
export type StaffRole = 'support' | 'accounting' | 'admin' | 'superadmin';
/** management: nur Management-Auswertung (analytics.read, aus dem Modul analytics), sonst nichts (#133). */
export type StaffRole = 'support' | 'accounting' | 'admin' | 'superadmin' | 'management';
export type OrgRole = 'owner' | 'admin' | 'member';
const STAFF: Record<StaffRole, string[]> = {
@ -7,6 +8,7 @@ const STAFF: Record<StaffRole, string[]> = {
accounting: ['customers.read'],
admin: ['customers.read', 'customers.write', 'users.read', 'users.write', 'audit.read', 'jobs.read'],
superadmin: ['customers.read', 'customers.write', 'users.read', 'users.write', 'users.write_privileged', 'audit.read', 'jobs.read', 'settings.write'],
management: [],
};
const ORG: Record<OrgRole, string[]> = {
owner: ['org.read', 'org.members.read', 'org.members.invite'],

View file

@ -0,0 +1,67 @@
import type { FastifyInstance } from 'fastify';
import { z } from 'zod';
import { one, query } from '../../core/db.js';
import { requirePermission } from '../../core/auth.js';
import { badRequest } from '../../core/errors.js';
import type { KcModule } from '../../core/module.js';
/**
* Management-Auswertung (#133), rein lesend. Alle Kennzahlen kommen aus vorhandenen Kunden-, Vertrags-, Rechnungs- und
* Produktdaten (keine externe Analyse, keine Testdaten-Vermischung: die Produktivdatenbank enthält nur echte Vorgänge).
* Definitionen (auch in der Antwort unter `definitions` und in docs/management-auswertung.md):
* - Zeitraum: Rechnungsdatum (issue_date) von `from` bis einschließlich `to`; Entwürfe zählen nie.
* - Beträge in Cent, Währung EUR, netto/Steuer/brutto getrennt. Stornos sind eigene Rechnungen mit negativen
* Beträgen und werden getrennt ausgewiesen; „netto nach Storno“ = ausgestellt + Stornos.
* - „als bezahlt markiert“ ist der Rechnungsstatus, KEIN gebuchter Zahlungseingang; nichts hier ist Gewinn oder Umsatz
* im bilanziellen Sinn.
*/
const DAY = /^\d{4}-\d{2}-\d{2}$/;
const n = (v: unknown) => Number(v ?? 0);
const money = (r: any) => ({ count: n(r?.c), netCents: n(r?.net), taxCents: n(r?.tax), grossCents: n(r?.gross) });
export const analyticsModule: KcModule = {
name: 'analytics',
permissions: { staff: { management: ['analytics.read'] } },
register(app: FastifyInstance) {
app.get('/analytics/summary', async (req) => {
requirePermission(req, 'analytics.read');
const q = z.object({ from: z.string().regex(DAY), to: z.string().regex(DAY) }).parse(req.query);
const from = new Date(`${q.from}T00:00:00Z`); const to = new Date(`${q.to}T00:00:00Z`);
if (Number.isNaN(from.getTime()) || Number.isNaN(to.getTime()) || to < from) throw badRequest('Zeitraum ungültig', 'BAD_RANGE');
if (to.getTime() - from.getTime() > 3 * 366 * 86400000) throw badRequest('Höchstens drei Jahre auf einmal', 'RANGE_TOO_LONG');
const P = [q.from, q.to];
const IN = "v.status <> 'draft' AND v.issue_date BETWEEN ? AND ?";
const sum = (extra: string, params: unknown[] = []) => one(`SELECT COUNT(*) AS c, SUM(v.total_net_cents) AS net, SUM(v.total_tax_cents) AS tax, SUM(v.total_gross_cents) AS gross FROM invoices v WHERE ${IN} ${extra}`, [...P, ...params]);
const issued = money(await sum('AND v.cancels_invoice_id IS NULL'));
const credits = money(await sum('AND v.cancels_invoice_id IS NOT NULL'));
const paid = money(await sum("AND v.cancels_invoice_id IS NULL AND v.status = 'paid'"));
const open = money(await sum("AND v.cancels_invoice_id IS NULL AND v.status = 'open'"));
const overdue = money(await sum("AND v.cancels_invoice_id IS NULL AND v.status = 'open' AND v.due_date < CURDATE()"));
const byTax = (await query(`SELECT ii.tax_bp, SUM(ii.net_cents) AS net, SUM(ii.tax_cents) AS tax, SUM(ii.gross_cents) AS gross FROM invoice_items ii JOIN invoices v ON v.id = ii.invoice_id WHERE ${IN} GROUP BY ii.tax_bp ORDER BY ii.tax_bp DESC`, P))
.map((r) => ({ taxBp: n(r.tax_bp), netCents: n(r.net), taxCents: n(r.tax), grossCents: n(r.gross) }));
const byCategory = (await query(`SELECT COALESCE(p.category, 'ohne_vertrag') AS cat, SUM(ii.net_cents) AS net, SUM(ii.gross_cents) AS gross
FROM invoice_items ii JOIN invoices v ON v.id = ii.invoice_id LEFT JOIN contracts c ON c.id = ii.contract_id
LEFT JOIN product_versions pv ON pv.id = c.product_version_id LEFT JOIN products p ON p.id = pv.product_id
WHERE ${IN} GROUP BY cat ORDER BY net DESC`, P)).map((r) => ({ category: r.cat, netCents: n(r.net), grossCents: n(r.gross) }));
const byMonth = (await query(`SELECT DATE_FORMAT(v.issue_date, '%Y-%m') AS m, SUM(IF(v.cancels_invoice_id IS NULL, v.total_net_cents, 0)) AS issued, SUM(IF(v.cancels_invoice_id IS NOT NULL, v.total_net_cents, 0)) AS credits
FROM invoices v WHERE ${IN} GROUP BY m ORDER BY m`, P)).map((r) => ({ month: r.m, issuedNetCents: n(r.issued), creditNetCents: n(r.credits), netAfterCreditsCents: n(r.issued) + n(r.credits) }));
const cust = await one(`SELECT SUM(status = 'active') AS active, SUM(status = 'suspended') AS suspended, SUM(DATE(created_at) BETWEEN ? AND ?) AS created FROM organizations`, P);
const con = await one(`SELECT SUM(status = 'active') AS active, SUM(DATE(created_at) BETWEEN ? AND ?) AS created, SUM(DATE(cancelled_at) BETWEEN ? AND ?) AS ended FROM contracts`, [...P, ...P]);
return {
period: { from: q.from, to: q.to, basis: 'Rechnungsdatum, beide Tage einschließlich' }, currency: 'EUR', dataAsOf: new Date().toISOString(),
customers: { activeNow: n(cust?.active), suspendedNow: n(cust?.suspended), createdInPeriod: n(cust?.created) },
contracts: { activeNow: n(con?.active), createdInPeriod: n(con?.created), endedInPeriod: n(con?.ended) },
invoices: { issued, credits, netAfterCreditsCents: issued.netCents + credits.netCents, grossAfterCreditsCents: issued.grossCents + credits.grossCents, markedPaid: paid, open, overdueNow: overdue },
byTaxRate: byTax, byCategory, byMonth,
definitions: [
'Zeitraum nach Rechnungsdatum; Entwürfe zählen nicht.',
'Stornos sind eigene Rechnungen mit negativen Beträgen und werden getrennt ausgewiesen.',
'„Als bezahlt markiert“ ist ein Rechnungsstatus, kein gebuchter Zahlungseingang.',
'Rechnungsbeträge sind weder Gewinn noch Umsatz im bilanziellen Sinn.',
'„ohne_vertrag“: Positionen ohne Vertragsbezug (z. B. Domains oder manuelle Positionen).',
'Kunden/Verträge „aktiv“ ist der Stand zum Abrufzeitpunkt, nicht zum Zeitraumende.',
],
};
});
},
};

View file

@ -5,13 +5,12 @@ import { audit, verifyAuditChain, purgeAuditRetention } from '../../core/audit.j
import { clientIp, requirePermission } from '../../core/auth.js';
import { badRequest } from '../../core/errors.js';
import type { KcModule } from '../../core/module.js';
import { csvCell } from '@kc/platform/csv';
const AUDIT_SQL = 'SELECT id, ts, actor_type, actor_id, org_id, action, resource_type, resource_id, result, error_class, correlation_id, ip, before_json, after_json FROM audit_events';
const listQuery = z.object({ action: z.string().max(100).optional(), actor: z.string().uuid().optional(), org: z.string().uuid().optional(), from: z.string().date().optional(), to: z.string().date().optional() });
// Formel-Injection-Schutz wie im Rechnungs-CSV-Export (apps/api/src/modules/invoices/index.ts) - hier lokal
// dupliziert statt importiert, damit Module weiterhin ohne Querverweise aufeinander auskommen.
const csvSafe = (s: string) => (/^[=+\-@\t]/.test(s) ? `'${s}` : s);
const csvCell = (s: string) => { const v = csvSafe(s); return /[;"\n]/.test(v) ? `"${v.replace(/"/g, '""')}"` : v; };
export const auditModule: KcModule = {
name: 'audit',

View file

@ -7,16 +7,19 @@ import { clientIp, requireAuth, requirePermission, IMPERSONATION_MINUTES } from
import { badRequest, conflict, forbidden, notFound } from '../../core/errors.js';
import { assertCustomerCapacity } from '../../core/license.js';
import { canInOrg } from '../../core/policy.js';
import { createInvitedUser, createToken, inviteLink, mailInvite } from '../../core/accounts.js';
import { ARGON, createInvitedUser, createToken, inviteLink, mailInvite } from '../../core/accounts.js';
import { enqueue } from '../../core/jobs.js';
import { calculatePrice } from '@kc/platform/pricing';
import { addMonths, consumerTerms } from '@kc/platform/contractterms';
import { getConnector, loadInstance, syncInstance } from '@kc/connectors';
import { ConnectorError, type ImportableCustomer } from '@kc/connector-sdk';
import { AppError } from '../../core/errors.js';
import { config } from '../../core/config.js';
import { config, rl } from '../../core/config.js';
import { sha256 } from '../../core/crypto.js';
import { hash } from '@node-rs/argon2';
import { sendTemplateMail } from '../../core/mail.js';
import type { KcModule } from '../../core/module.js';
import { enqueueCustomerSync } from '@kc/platform/customerSync';
const deMoney = (cents: number) => (cents / 100).toLocaleString('de-DE', { style: 'currency', currency: 'EUR' });
const INTERVAL_LABEL: Record<string, string> = { once: 'einmalig', monthly: 'monatlich', yearly: 'jährlich' };
@ -105,6 +108,93 @@ export const customersModule: KcModule = {
return { id: orgId, customerNumber: res.number, mail, inviteLink: mail === 'sent' ? undefined : inviteLink(res.inv.token) };
});
// ---- Selbstregistrierung (#36) – nur wenn settings.registration_enabled = 'true' --------------------------
const regSettings = async () => {
const rows = await query("SELECT `key`, `value` FROM settings WHERE `key` IN ('registration_enabled','registration_approval')");
const m = Object.fromEntries(rows.map((r) => [r.key, r.value]));
return { enabled: m.registration_enabled === 'true', approval: (m.registration_approval === 'auto' ? 'auto' : 'manual') as 'auto' | 'manual' };
};
app.get('/auth/registration', async () => ({ enabled: (await regSettings()).enabled }));
/** Antwortet immer gleich (202), egal ob die E-Mail schon existiert – keine Auskunft über bestehende Konten. */
app.post('/auth/register', { config: rl(5, '10 minutes') }, async (req, reply) => {
const rs = await regSettings();
if (!rs.enabled) throw notFound();
const b = z.object({
type: z.enum(['private', 'business']), name: z.string().trim().min(2).max(200), contactName: z.string().trim().min(2).max(150).optional(),
email, password: z.string().min(12).max(200), repeat: z.string(), vatId: z.string().trim().max(30).optional(), acceptPrivacy: z.literal(true),
}).parse(req.body);
if (b.password !== b.repeat) throw badRequest('Die Passwörter stimmen nicht überein', 'PASSWORD_MISMATCH');
const vatId = normVat(b.vatId) ?? null;
applyTypeRules(b.type, b.name, { vatId: b.type === 'business' ? vatId : (b.vatId ? vatId : null) });
const existing = await one('SELECT id FROM users WHERE email = ?', [b.email]);
if (existing) {
await sendTemplateMail(b.email, 'registration_exists', { loginLink: `${config.baseUrl}/login`, resetLink: `${config.baseUrl}/passwort-vergessen` }).catch(() => undefined);
await audit({ actorType: 'anonymous', action: 'customer.register', result: 'denied', errorClass: 'email_exists', correlationId: req.correlationId, ip: clientIp(req) });
return reply.code(202).send({ status: 'check_mail' });
}
const orgId = randomUUID(); const userId = randomUUID(); const pw = await hash(b.password, ARGON);
const contact = b.type === 'private' ? b.name : (b.contactName ?? b.name);
const token = await tx(async (c) => {
const cap = await assertCustomerCapacity(c); // Kundengrenze gilt auch hier
if (!cap.allowed) throw forbidden('Eine Registrierung ist derzeit nicht möglich. Bitte wenden Sie sich an den Support.', 'REGISTRATION_UNAVAILABLE');
const number = await nextCustomerNumber(c);
await run("INSERT INTO organizations (id, customer_number, name, customer_type, source) VALUES (?,?,?,?, 'registration')", [orgId, number, b.name, b.type], c);
await run('INSERT INTO billing_profiles (org_id, company, contact_name, country, vat_id, billing_email) VALUES (?,?,?,?,?,?)', [orgId, b.type === 'business' ? b.name : null, contact, 'DE', b.type === 'business' ? vatId : null, b.email], c);
// Konto bleibt 'invited' (keine Anmeldung möglich), bis die E-Mail bestätigt und – je nach Regel – freigegeben ist
await run("INSERT INTO users (id, email, name, password_hash, kind, status) VALUES (?,?,?,?, 'customer', 'invited')", [userId, b.email, contact, pw], c);
await run("INSERT INTO memberships (org_id, user_id, role) VALUES (?,?,'owner')", [orgId, userId], c);
return createToken(c, userId, 'verify_email');
});
await sendTemplateMail(b.email, 'verify_email', { name: contact, verifyLink: `${config.baseUrl}/email-bestaetigen?token=${encodeURIComponent(token)}`, validHours: '24' }).catch(() => undefined);
await audit({ actorType: 'anonymous', orgId, action: 'customer.register', resourceType: 'organization', resourceId: orgId, correlationId: req.correlationId, ip: clientIp(req), after: { customerType: b.type } });
return reply.code(202).send({ status: 'check_mail' });
});
app.post('/auth/verify-email', { config: rl(10, '10 minutes') }, async (req) => {
const { token } = z.object({ token: z.string().min(20).max(200) }).parse(req.body);
const rs = await regSettings();
const res = await tx(async (c) => {
const t = await one("SELECT id, user_id FROM user_tokens WHERE token_hash = ? AND purpose = 'verify_email' AND used_at IS NULL AND expires_at > UTC_TIMESTAMP(3) FOR UPDATE", [sha256(token)], c);
if (!t) throw badRequest('Der Link ist ungültig oder abgelaufen. Bitte registrieren Sie sich erneut oder wenden Sie sich an den Support.', 'TOKEN_INVALID');
await run('UPDATE user_tokens SET used_at = UTC_TIMESTAMP(3) WHERE id = ?', [t.id], c);
await run("UPDATE users SET email_verified_at = UTC_TIMESTAMP(3), status = IF(? = 'auto', 'active', status) WHERE id = ?", [rs.approval, t.user_id], c);
const m = await one("SELECT org_id FROM memberships WHERE user_id = ? AND role = 'owner'", [t.user_id], c);
return { userId: t.user_id as string, orgId: m?.org_id as string | undefined };
});
await audit({ actorType: 'user', actorId: res.userId, orgId: res.orgId, action: 'customer.register.verified', resourceType: 'user', resourceId: res.userId, correlationId: req.correlationId, ip: clientIp(req), after: { approval: rs.approval } });
if (rs.approval === 'manual') await enqueue('discord.notify', { event: 'customer.registered' }, { idempotencyKey: `customer.registered:${res.userId}`, correlationId: req.correlationId });
return { status: rs.approval === 'auto' ? 'active' : 'pending_approval' };
});
app.get('/admin/registration-settings', async (req) => { requirePermission(req, 'customers.read'); return regSettings(); });
app.put('/admin/registration-settings', async (req) => {
const a = requirePermission(req, 'settings.write');
const b = z.object({ enabled: z.boolean(), approval: z.enum(['manual', 'auto']) }).parse(req.body);
await run("INSERT INTO settings (`key`, `value`) VALUES ('registration_enabled', ?), ('registration_approval', ?) ON DUPLICATE KEY UPDATE `value` = VALUES(`value`)", [String(b.enabled), b.approval]);
await audit({ actorType: 'user', actorId: a.user.id, action: 'settings.registration', resourceType: 'settings', resourceId: 'registration', correlationId: req.correlationId, ip: clientIp(req), after: b });
return regSettings();
});
/** Bestätigte, noch nicht freigegebene Registrierungen (Freischaltung „manuell“). */
app.get('/admin/registrations', async (req) => {
requirePermission(req, 'customers.read');
const rows = await query(`SELECT u.id AS user_id, u.email, u.name, u.email_verified_at, o.id AS org_id, o.name AS org_name, o.customer_number, o.customer_type
FROM users u JOIN memberships m ON m.user_id = u.id AND m.role = 'owner' JOIN organizations o ON o.id = m.org_id
WHERE o.source = 'registration' AND u.status = 'invited' AND u.email_verified_at IS NOT NULL ORDER BY u.email_verified_at`);
return rows.map((r) => ({ userId: r.user_id, email: r.email, name: r.name, verifiedAt: r.email_verified_at, orgId: r.org_id, orgName: r.org_name, customerNumber: r.customer_number, customerType: r.customer_type }));
});
app.post('/admin/registrations/:userId/:decision', async (req) => {
const a = requirePermission(req, 'customers.write');
const { userId, decision } = z.object({ userId: z.string().uuid(), decision: z.enum(['approve', 'reject']) }).parse(req.params);
const r = await tx(async (c) => {
const u = await one("SELECT u.id, u.email, u.name, m.org_id FROM users u JOIN memberships m ON m.user_id = u.id AND m.role = 'owner' JOIN organizations o ON o.id = m.org_id AND o.source = 'registration' WHERE u.id = ? AND u.status = 'invited' AND u.email_verified_at IS NOT NULL FOR UPDATE", [userId], c);
if (!u) throw notFound();
if (decision === 'approve') await run("UPDATE users SET status = 'active' WHERE id = ?", [userId], c);
else { await run("UPDATE users SET status = 'disabled' WHERE id = ?", [userId], c); await run("UPDATE organizations SET status = 'closed' WHERE id = ?", [u.org_id], c); }
return u;
});
await audit({ actorType: 'user', actorId: a.user.id, orgId: r.org_id, action: `customer.register.${decision}`, resourceType: 'user', resourceId: userId, correlationId: req.correlationId, ip: clientIp(req) });
if (decision === 'approve') await sendTemplateMail(r.email, 'registration_approved', { name: r.name, loginLink: `${config.baseUrl}/login` }).catch(() => undefined);
return { ok: true };
});
app.get('/admin/customers/:id', async (req) => {
requirePermission(req, 'customers.read');
const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
@ -115,6 +205,16 @@ export const customersModule: KcModule = {
* Sicht dieses Kunden um (echte Rechteeinschränkung, nicht nur eine andere Oberfläche). Admin/Superadmin
* only; Grund ist Pflicht und wird protokolliert. Lässt sich nicht verschachteln (erfordert customers.read,
* das während einer laufenden Impersonation nicht mehr greift). */
/** Kundenangaben an allen Lizenzen dieses Kunden beim Anbieter nachziehen bzw. (Löschanspruch) leeren (#64). */
app.post('/admin/customers/:id/provider-sync', async (req) => {
const a = requirePermission(req, 'customers.write');
const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const { mode } = z.object({ mode: z.enum(['update', 'erase']) }).parse(req.body);
if (!(await one('SELECT 1 AS x FROM organizations WHERE id = ?', [id]))) throw notFound();
await enqueueCustomerSync(id, mode, a.user.id, req.correlationId);
await audit({ actorType: 'user', actorId: a.user.id, orgId: id, action: `customer.provider_sync.request.${mode}`, resourceType: 'organization', resourceId: id, correlationId: req.correlationId, ip: clientIp(req) });
return { status: 'queued' };
});
app.post('/admin/customers/:id/impersonate', async (req) => {
const a = requirePermission(req, 'customers.impersonate');
const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
@ -165,15 +265,20 @@ export const customersModule: KcModule = {
if (type === 'private' && (after.company || after.vatId)) throw badRequest('Privatkunden haben keine Firma und keine USt-IdNr. Bitte beides entfernen.', 'PRIVATE_NO_COMPANY');
if (type === 'business') { if (!(after.company || name)) throw badRequest('Geschäftskunden benötigen einen Firmennamen', 'BUSINESS_NEEDS_COMPANY'); applyTypeRules('business', name, { vatId: after.vatId ?? undefined }); }
await tx(async (c) => {
if (b.status === 'active' && before.status === 'closed') {
// Jeder Wechsel von "closed" in einen zählenden Zustand (active ODER suspended) belegt wieder einen Platz der
// Kundengrenze. Erst die Kapazitätssperre, dann den aktuellen Zustand unter Zeilensperre lesen – nicht den vor der
// Transaktion gelesenen (ein paralleler Aufruf könnte ihn inzwischen geändert haben).
if (b.status && b.status !== 'closed') {
const cap = await assertCustomerCapacity(c);
if (!cap.allowed) throw forbidden(cap.reason!, 'CUSTOMER_LIMIT_REACHED');
const cur = await one('SELECT status FROM organizations WHERE id = ? FOR UPDATE', [id], c);
if (cur?.status === 'closed' && !cap.allowed) throw forbidden(cap.reason!, 'CUSTOMER_LIMIT_REACHED');
}
if (b.name || b.status || b.customerType) await run('UPDATE organizations SET name = COALESCE(?, name), status = COALESCE(?, status), customer_type = COALESCE(?, customer_type) WHERE id = ?', [b.name ?? null, b.status ?? null, b.customerType ?? null, id], c);
const keys = Object.keys(patch);
if (keys.length) await run(`UPDATE billing_profiles SET ${keys.map((k) => `${cols[k]} = ?`).join(', ')} WHERE org_id = ?`, [...keys.map((k) => patch[k] ?? null), id], c);
});
await audit({ actorType: 'user', actorId: a.user.id, orgId: id, action: 'customer.update', resourceType: 'organization', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), before, after: b });
if (b.name !== undefined && b.name !== before.name) await enqueueCustomerSync(id, 'update', a.user.id, req.correlationId); // Kundenname an Lizenzen nachziehen (#64)
return loadOrg(id);
});

View file

@ -8,29 +8,14 @@ import { rl } from '../../core/config.js';
import type { KcModule } from '../../core/module.js';
import { randomUUID } from 'node:crypto';
import { loadInstance } from '@kc/connectors';
import { breakdown, checkAvailability, normalizeDomain, parsePriceList, sellPrice, splitDomain, type CostBasis, type Margin } from './logic.js';
import { checkAvailability, domainOffer as offer, domainQuote as snapshot, domainSettings as settings, domainTaxBp as taxBp, normalizeDomain, parsePriceList, sellPrice, splitDomain, type Margin } from '@kc/platform/domains';
const taxBp = async () => Number((await one("SELECT rate_bp FROM tax_rates WHERE name LIKE 'Regelsteuersatz%' LIMIT 1"))?.rate_bp ?? 1900);
/** Preis-Schnappschuss für eine Domain: Einkauf brutto/netto und errechneter Verkauf brutto/netto. Null-Preise, wenn Endung fehlt oder kein Aufschlag festgelegt ist. */
async function snapshot(tld: string) {
const s = await settings(); const r = await one('SELECT * FROM domain_tlds WHERE tld = ?', [tld]); const tax = await taxBp();
if (!r) return { termMonths: null, costNet: null, costGross: null, setup: 0, net: null, gross: null, tax };
const o = offer(r, s.tier, s.margin, s.rounding, s.basis, tax);
return { termMonths: o.termMonths, costNet: o.costNetCents, costGross: o.costGrossCents, setup: o.setupGrossCents, net: o.priceNetCents, gross: o.priceGrossCents, tax };
}
const recView = (r: any) => ({ id: r.id, domain: r.domain, tld: r.tld, orgId: r.org_id, customer: r.org_name ?? null, customerNumber: r.customer_number ?? null, resourceId: r.resource_id, source: r.source, termMonths: r.term_months,
costNetCents: r.cost_net_cents, costGrossCents: r.cost_gross_cents, setupCostCents: r.setup_cost_cents, sellNetCents: r.sell_net_cents, taxBp: r.tax_bp, sellGrossCents: r.sell_gross_cents, profitNetCents: r.sell_net_cents === null || r.cost_net_cents === null ? null : r.sell_net_cents - r.cost_net_cents,
procurement: r.procurement, orderedAt: r.ordered_at, note: r.note, pricedAt: r.priced_at, createdAt: r.created_at });
const REC_SELECT = 'SELECT d.*, o.name AS org_name, o.customer_number FROM domain_records d LEFT JOIN organizations o ON o.id = d.org_id';
const SUGGEST = ['de', 'com', 'net', 'org', 'eu', 'info'];
const marginIn = z.object({ type: z.enum(['percent', 'fixed']).nullable(), value: z.number().int().min(0).max(100_000_00).nullable() }).refine((m) => (m.type === null) === (m.value === null), 'Art und Wert gehören zusammen');
async function settings() { const s = await one('SELECT tier, margin_type, margin_value, rounding, cost_basis FROM domain_settings WHERE id = 1'); return { tier: Number(s?.tier ?? 1), rounding: s ? !!s.rounding : true, basis: (s?.cost_basis ?? 'gross') as CostBasis, margin: { type: s?.margin_type ?? null, value: s?.margin_value ?? null } as Margin }; }
const offer = (r: any, tier: number, g: Margin, round: boolean, basis: CostBasis, tax: number) => {
const list = Number(r[`cost${tier}_cents`]); const own: Margin = { type: r.margin_type, value: r.margin_value }; const b = breakdown(list, own, g, round, basis, tax);
const setupGross = basis === 'gross' ? r.setup_cents : r.setup_cents + Math.round((r.setup_cents * tax) / 10000);
return { tld: r.tld, termMonths: r.term_months, ...b, setupGrossCents: setupGross as number, setupNetCents: Math.round((setupGross * 10000) / (10000 + tax)), taxBp: tax, margin: own, active: !!r.active };
};
export const domainsModule: KcModule = {
name: 'domains',
permissions: { staff: { support: ['domains.read'], accounting: ['domains.read'], admin: ['domains.read', 'domains.write'], superadmin: ['domains.read', 'domains.write'] } },

View file

@ -1,93 +1,2 @@
import { domainToASCII } from 'node:url';
import { promises as dns } from 'node:dns';
export type MarginType = 'percent' | 'fixed';
export interface Margin { type: MarginType | null; value: number | null }
/** Kaufmännische Rundung nach oben: Cent-Anteil 00–50 → ,50; 51–99 → ,99 (z. B. 12,00 → 12,50; 12,51 → 12,99). */
export function roundPrice(cents: number): number { const euro = Math.floor(cents / 100), c = cents % 100; return euro * 100 + (c <= 50 ? 50 : 99); }
/** Verkaufspreis (netto, Cent) = Einkauf + Gewinnaufschlag; null, wenn kein Aufschlag festgelegt ist. Prozent in Basispunkten. */
export function sellPrice(costCents: number, own: Margin, global: Margin, round = false): number | null {
const m = own.type && own.value !== null ? own : global; if (!m.type || m.value === null) return null;
const p = costCents + (m.type === 'percent' ? Math.round((costCents * m.value) / 10000) : m.value); return round ? roundPrice(p) : p;
}
export type CostBasis = 'gross' | 'net';
export interface Breakdown { costGrossCents: number; costNetCents: number; priceGrossCents: number | null; priceNetCents: number | null; profitNetCents: number | null }
/** Preise aus dem Listenpreis: Ist die Liste brutto (inkl. USt), wird Netto herausgerechnet, nie erneut USt aufgeschlagen. Rundung und Aufschlag wirken auf die Listenbasis. */
export function breakdown(listCost: number, own: Margin, global: Margin, round: boolean, basis: CostBasis, taxBp: number): Breakdown {
const toNet = (g: number) => Math.round((g * 10000) / (10000 + taxBp)); const vat = (n: number) => Math.round((n * taxBp) / 10000);
const p = sellPrice(listCost, own, global, round);
const costGross = basis === 'gross' ? listCost : listCost + vat(listCost); const costNet = basis === 'gross' ? toNet(listCost) : listCost;
if (p === null) return { costGrossCents: costGross, costNetCents: costNet, priceGrossCents: null, priceNetCents: null, profitNetCents: null };
const g = basis === 'gross' ? p : p + vat(p); const n = basis === 'gross' ? toNet(p) : p;
return { costGrossCents: costGross, costNetCents: costNet, priceGrossCents: g, priceNetCents: n, profitNetCents: n - costNet };
}
export interface ParsedRow { tld: string; termMonths: number; costs: [number, number, number, number]; setupCents: number }
const num = (s: string): number | null => {
const t = s.replace(/[€\s]/g, ''); if (!t) return null;
const n = t.includes(',') ? t.replace(/\./g, '').replace(',', '.') : t; // deutsches Format 1.380,00 oder 26.60
return /^\d+(\.\d+)?$/.test(n) ? Math.round(Number(n) * 100) : null;
};
/** Liest eine Preisliste (Tabulator/Leerzeichen getrennt): Endung, Laufzeit, 4 Staffelpreise, optional Setup. Kopf-/Fußzeilen werden übersprungen. */
export function parsePriceList(text: string): { rows: ParsedRow[]; skipped: string[] } {
const rows: ParsedRow[] = []; const skipped: string[] = []; const seen = new Set<string>();
for (const raw of text.split(/\r?\n/)) {
const line = raw.trim(); if (!line || line.startsWith('#')) continue;
const c = line.split(/[\t ]+/).filter((x) => x !== '€');
const tld = (c[0] ?? '').toLowerCase().replace(/^\./, '');
if (!/^[a-z0-9]([a-z0-9.-]{0,60}[a-z0-9])?$/.test(tld) || !/^\d{1,3}$/.test(c[1] ?? '')) { if (!/^Domaintyp/i.test(line)) skipped.push(line.slice(0, 80)); continue; }
const p = [2, 3, 4, 5].map((i) => num(c[i] ?? '')); const setup = c[6] !== undefined ? num(c[6]) : 0;
if (p.some((x) => x === null) || setup === null) { skipped.push(line.slice(0, 80)); continue; }
if (seen.has(tld)) { skipped.push(`doppelt: ${tld}`); continue; } seen.add(tld);
rows.push({ tld, termMonths: Number(c[1]), costs: p as [number, number, number, number], setupCents: setup });
}
return { rows, skipped };
}
/** Normalisiert Eingaben wie „https://www.Beispiel.de/x“ zu „beispiel.de“ (Punycode). */
export function normalizeDomain(input: string): string | null {
let s = input.trim().toLowerCase().replace(/^[a-z]+:\/\//, '').replace(/[/?#].*$/, '').replace(/^www\./, '').replace(/\.$/, '');
if (!s || s.length > 253) return null; s = domainToASCII(s); if (!s) return null;
return s.split('.').every((l) => /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/.test(l)) ? s : null;
}
/** Trennt Name und Endung; bekannte mehrteilige Endungen (co.uk) werden bevorzugt. */
export function splitDomain(name: string, known: Set<string>): { label: string; tld: string } | null {
const parts = name.split('.'); if (parts.length < 2) return null;
for (let i = 1; i < parts.length; i++) { const tld = parts.slice(i).join('.'); if (known.has(tld) && parts.slice(0, i).length === 1) return { label: parts[0]!, tld }; }
for (let i = 1; i < parts.length; i++) { const tld = parts.slice(i).join('.'); if (known.has(tld)) return { label: parts.slice(0, i).join('.'), tld }; }
return { label: parts.slice(0, -1).join('.'), tld: parts[parts.length - 1]! };
}
export type Availability = { status: 'available' | 'registered' | 'unknown'; method: 'rdap' | 'dns'; note?: string };
/** Ergänzung für Endungen, die nicht in der IANA-Liste stehen, aber eine RDAP-Auskunft anbieten. */
const EXTRA_RDAP: Record<string, string> = { de: 'https://rdap.denic.de/' };
let boot: { at: number; map: Map<string, string> } | null = null;
async function rdapBase(tld: string): Promise<string | null> {
if (!boot || Date.now() - boot.at > 24 * 3600_000) {
const r = await fetch('https://data.iana.org/rdap/dns.json', { signal: AbortSignal.timeout(8000) }); if (!r.ok) throw new Error(`IANA ${r.status}`);
const j = (await r.json()) as { services: [string[], string[]][] }; const map = new Map<string, string>();
for (const [tlds, urls] of j.services) { const u = urls.find((x) => x.startsWith('https://')); if (u) for (const t of tlds) map.set(t.toLowerCase(), u.endsWith('/') ? u : `${u}/`); }
boot = { at: Date.now(), map };
}
const last = tld.split('.').pop()!; return boot.map.get(last) ?? EXTRA_RDAP[last] ?? null;
}
async function viaDns(name: string): Promise<Availability> {
try { await dns.resolveNs(name); return { status: 'registered', method: 'dns' }; } catch (e) {
const c = (e as { code?: string }).code;
if (c === 'ENOTFOUND') return { status: 'available', method: 'dns', note: 'Ermittelt über DNS, ohne Gewähr. Vor der Bestellung wird beim Registrar erneut geprüft.' };
if (c === 'ENODATA') { try { await dns.resolveSoa(name); return { status: 'registered', method: 'dns' }; } catch { return { status: 'unknown', method: 'dns' }; } }
return { status: 'unknown', method: 'dns' };
}
}
/** Prüft, ob eine Domain vergeben ist: bevorzugt per RDAP (Registry-Auskunft), sonst per DNS. */
export async function checkAvailability(name: string): Promise<Availability> {
try {
const base = await rdapBase(name.split('.').slice(1).join('.'));
if (base) {
const r = await fetch(`${base}domain/${encodeURIComponent(name)}`, { signal: AbortSignal.timeout(7000), headers: { accept: 'application/rdap+json, application/json' }, redirect: 'follow' });
if (r.status === 200) return { status: 'registered', method: 'rdap' };
if (r.status === 404) return { status: 'available', method: 'rdap' };
}
} catch { /* Fallback auf DNS */ }
return viaDns(name);
}
// Domain-Preislogik und Prüfung liegen in @kc/platform/domains (gemeinsam mit Bestellungen, #80).
export * from '@kc/platform/domains';

View file

@ -11,11 +11,11 @@ import { badRequest, conflict, forbidden, notFound, unauthorized } from '../../c
import { assertStaffCapacity } from '../../core/license.js';
import { decrypt, encrypt, sha256 } from '../../core/crypto.js';
import { can, staffPermissions } from '../../core/policy.js';
import { createInvitedUser, createToken, mailInvite, inviteLink, resetLink } from '../../core/accounts.js';
import { createInvitedUser, createToken, mailInvite, inviteLink, resetLink, ARGON } from '../../core/accounts.js';
import { sendTemplateMail } from '../../core/mail.js';
import type { KcModule } from '../../core/module.js';
import { enqueueSyncForOwner } from '@kc/platform/customerSync';
const ARGON = { memoryCost: 19456, timeCost: 2, parallelism: 1 };
const MAX_FAILS = 5;
const LOCK_MINUTES = 15;
const password = z.string().min(12, 'Mindestens 12 Zeichen').max(200);
@ -237,12 +237,15 @@ export const identityModule: KcModule = {
});
app.post('/admin/users', async (req) => {
const a = requirePermission(req, 'users.write');
const b = z.object({ email, name: z.string().min(1).max(150), staffRole: z.enum(['support', 'accounting', 'admin', 'superadmin']) }).parse(req.body);
if ((b.staffRole === 'admin' || b.staffRole === 'superadmin') && !can(a.principal, 'users.write_privileged')) throw forbidden('Nur Superadministratoren dürfen Administratoren anlegen', 'PRIVILEGED_ONLY');
const b = z.object({ email, name: z.string().min(1).max(150), staffRole: z.enum(['support', 'accounting', 'admin', 'superadmin', 'management']) }).parse(req.body);
// admin/superadmin und die Management-Rolle (organisationsübergreifende Finanzkennzahlen) vergibt nur ein Superadmin
if (['admin', 'superadmin', 'management'].includes(b.staffRole) && !can(a.principal, 'users.write_privileged')) throw forbidden('Nur Superadministratoren dürfen diese Rolle vergeben', 'PRIVILEGED_ONLY');
if (await one('SELECT 1 AS x FROM users WHERE email = ?', [b.email])) throw conflict('E-Mail bereits vergeben', 'EMAIL_EXISTS');
const cap = await assertStaffCapacity();
if (!cap.allowed) throw forbidden(cap.reason!, 'STAFF_LIMIT_REACHED');
const inv = await tx((c) => createInvitedUser(c, { email: b.email, name: b.name, kind: 'staff', staffRole: b.staffRole }));
const inv = await tx(async (c) => {
const cap = await assertStaffCapacity(c); // Sperre hält bis zum Commit: der letzte freie Platz wird genau einmal vergeben
if (!cap.allowed) throw forbidden(cap.reason!, 'STAFF_LIMIT_REACHED');
return createInvitedUser(c, { email: b.email, name: b.name, kind: 'staff', staffRole: b.staffRole });
});
const mail = await mailInvite(b.email, b.name, inv.token);
await audit({ actorType: 'user', actorId: a.user.id, action: 'user.create', resourceType: 'user', resourceId: inv.userId, correlationId: req.correlationId, ip: clientIp(req), after: { email: b.email, kind: 'staff', staffRole: b.staffRole } });
return { id: inv.userId, mail, inviteLink: mail === 'sent' ? undefined : inviteLink(inv.token) };
@ -277,17 +280,36 @@ export const identityModule: KcModule = {
app.patch('/admin/users/:id', async (req) => {
const a = requirePermission(req, 'users.write');
const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const b = z.object({ status: z.enum(['active', 'disabled']).optional(), staffRole: z.enum(['support', 'accounting', 'admin', 'superadmin']).optional() }).parse(req.body);
const b = z.object({ status: z.enum(['active', 'disabled']).optional(), staffRole: z.enum(['support', 'accounting', 'admin', 'superadmin', 'management']).optional(), email: email.optional(), name: z.string().trim().min(1).max(150).optional() }).parse(req.body);
const u = await one('SELECT * FROM users WHERE id = ?', [id]);
if (!u) throw notFound();
if (id === a.user.id) throw forbidden('Eigenes Konto kann hier nicht geändert werden', 'SELF_CHANGE');
const privileged = (r: unknown) => r === 'admin' || r === 'superadmin';
const privileged = (r: unknown) => r === 'admin' || r === 'superadmin' || r === 'management';
if ((privileged(u.staff_role) || privileged(b.staffRole)) && !can(a.principal, 'users.write_privileged')) throw forbidden('Nur Superadministratoren', 'PRIVILEGED_ONLY');
if (b.staffRole && u.kind !== 'staff') throw badRequest('Nur für Mitarbeiter');
if (b.status === 'active' && u.status === 'invited') throw badRequest('Eingeladene Benutzer aktivieren sich selbst');
await run('UPDATE users SET status = COALESCE(?, status), staff_role = COALESCE(?, staff_role) WHERE id = ?', [b.status ?? null, b.staffRole ?? null, id]);
const emailChanged = b.email !== undefined && b.email !== u.email;
if (emailChanged) {
// Login-Adresse eines Mitarbeiters zu ändern ist eine Kontoübernahme-Möglichkeit: nur Superadmin
if (u.kind === 'staff' && !can(a.principal, 'users.write_privileged')) throw forbidden('Nur Superadministratoren dürfen die Anmelde-E-Mail von Mitarbeitern ändern', 'PRIVILEGED_ONLY');
if (await one('SELECT 1 AS x FROM users WHERE email = ? AND id <> ?', [b.email, id])) throw conflict('E-Mail bereits vergeben', 'EMAIL_EXISTS');
await run('UPDATE users SET email = ? WHERE id = ?', [b.email, id]);
// Offene Einladungs-/Reset-Links gingen an die alte Adresse und dürfen nicht mehr gelten; bestehende Sitzungen enden
await run('UPDATE user_tokens SET used_at = UTC_TIMESTAMP(3) WHERE user_id = ? AND used_at IS NULL', [id]);
await run('UPDATE sessions SET revoked_at = UTC_TIMESTAMP(3) WHERE user_id = ? AND revoked_at IS NULL', [id]);
}
if (b.name !== undefined) await run('UPDATE users SET name = ? WHERE id = ?', [b.name, id]);
await tx(async (c) => {
// Reaktivieren eines deaktivierten Mitarbeiters belegt wieder einen Platz der Benutzergrenze
if (b.status === 'active' && u.status === 'disabled' && u.kind === 'staff') {
const cap = await assertStaffCapacity(c);
if (!cap.allowed) throw forbidden(cap.reason!, 'STAFF_LIMIT_REACHED');
}
await run('UPDATE users SET status = COALESCE(?, status), staff_role = COALESCE(?, staff_role) WHERE id = ?', [b.status ?? null, b.staffRole ?? null, id], c);
});
if (b.status === 'disabled') await run('UPDATE sessions SET revoked_at = UTC_TIMESTAMP(3) WHERE user_id = ? AND revoked_at IS NULL', [id]);
await audit({ actorType: 'user', actorId: a.user.id, action: 'user.update', resourceType: 'user', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), before: { status: u.status, staffRole: u.staff_role }, after: b });
if (emailChanged || (b.name !== undefined && b.name !== u.name)) await enqueueSyncForOwner(id, a.user.id, req.correlationId); // Inhaber-Angaben an Lizenzen (#64)
await audit({ actorType: 'user', actorId: a.user.id, action: 'user.update', resourceType: 'user', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), before: { status: u.status, staffRole: u.staff_role, ...(emailChanged ? { email: u.email } : {}), ...(b.name !== undefined ? { name: u.name } : {}) }, after: b });
return { status: 'ok' };
});
},

View file

@ -15,6 +15,8 @@ import { mailModule } from './mail/index.js';
import { discordModule } from './discord/index.js';
import { licenseModule } from './license/index.js';
import { licensingModule } from './licensing/index.js';
import { statusModule } from './status/index.js';
import { analyticsModule } from './analytics/index.js';
/** Aktive Module. Neue Module (Produkte, Verträge, Connectoren, Tickets, Rechnungen) werden hier eingetragen. */
export const modules: KcModule[] = [systemModule, identityModule, customersModule, auditModule, connectorsModule, resourcesModule, catalogModule, domainsModule, ordersModule, ticketsModule, invoicesModule, backupModule, mailModule, discordModule, licenseModule, licensingModule];
export const modules: KcModule[] = [systemModule, identityModule, customersModule, auditModule, connectorsModule, resourcesModule, catalogModule, domainsModule, ordersModule, ticketsModule, invoicesModule, backupModule, mailModule, discordModule, licenseModule, licensingModule, statusModule, analyticsModule];

View file

@ -17,6 +17,8 @@ import { can, canInOrg } from '../../core/policy.js';
import type { KcModule } from '../../core/module.js';
import { config } from '../../core/config.js';
import { renderInvoicePdf, type CompanySettings, type InvoiceForPdf } from './pdf.js';
import { csvSafe, csvCell } from '@kc/platform/csv';
import { autoBillingEnabled, duePeriods, releaseCancelledPeriods, runBilling } from '@kc/platform/billing';
/** Kaufmännisches Runden (halb auf), wie in @kc/platform/pricing – hier lokal, weil Rechnungspositionen
* (Freitext, Dezimalmenge) sich nicht in das Produkt-Preisschema von calculatePrice pressen lassen. */
@ -96,8 +98,6 @@ function exportFilter(q: z.infer<typeof exportQuery>): { sql: string; params: un
const csvNum = (cents: number) => (cents / 100).toFixed(2).replace('.', ',');
// Formel-Injection-Schutz (CSV): Zellen, die mit =, +, -, @ oder Tab beginnen, werden von Excel/Sheets sonst als Formel
// ausgeführt. Firmenname/Notiz stammen aus vom Kunden bzw. Personal eingegebenen Feldern – daher immer entschärfen.
const csvSafe = (s: string): string => (/^[=+\-@\t]/.test(s) ? `'${s}` : s);
const csvCell = (s: string): string => { const v = csvSafe(s); return /[;"\n]/.test(v) ? `"${v.replace(/"/g, '""')}"` : v; };
const csvDate = (d: unknown) => (d ? new Date(d as string).toISOString().slice(0, 10) : '');
const STATUS_LABEL: Record<string, string> = { open: 'Offen', paid: 'Bezahlt', cancelled: 'Storniert' };
@ -193,7 +193,7 @@ export const invoicesModule: KcModule = {
app.get('/admin/company-settings', async (req) => {
requirePermission(req, 'invoices.read');
const s = await settings(); const d = await datevSettings();
return { ...s, complete: complete(s), datev: { ...d, complete: datevComplete(d) } };
return { ...s, complete: complete(s), datev: { ...d, complete: datevComplete(d) }, autoBillingRuns: await autoBillingEnabled() };
});
app.put('/admin/company-settings', async (req) => {
const a = requirePermission(req, 'settings.write');
@ -207,11 +207,12 @@ export const invoicesModule: KcModule = {
datevFiscalYearStart: z.string().regex(/^\d{2}-\d{2}$/).optional(),
datevErloeskonto19: z.number().int().min(0).max(999999999).nullable().optional(), datevErloeskonto7: z.number().int().min(0).max(999999999).nullable().optional(), datevErloeskonto0: z.number().int().min(0).max(999999999).nullable().optional(),
datevDiktatkuerzel: z.string().trim().max(2).nullable().optional(),
autoBillingRuns: z.boolean().optional(),
}).parse(req.body);
const cols: Record<string, string> = {
name: 'name', street: 'street', zip: 'zip', city: 'city', country: 'country', taxNumber: 'tax_number', vatId: 'vat_id', bankName: 'bank_name', iban: 'iban', bic: 'bic', invoicePrefix: 'invoice_prefix', defaultDueDays: 'default_due_days', footerText: 'footer_text',
datevBeraterNr: 'datev_berater_nr', datevMandantNr: 'datev_mandant_nr', datevSkr: 'datev_skr', datevSachkontenlaenge: 'datev_sachkontenlaenge', datevFiscalYearStart: 'datev_fiscal_year_start',
datevErloeskonto19: 'datev_erloeskonto_19', datevErloeskonto7: 'datev_erloeskonto_7', datevErloeskonto0: 'datev_erloeskonto_0', datevDiktatkuerzel: 'datev_diktatkuerzel',
datevErloeskonto19: 'datev_erloeskonto_19', datevErloeskonto7: 'datev_erloeskonto_7', datevErloeskonto0: 'datev_erloeskonto_0', datevDiktatkuerzel: 'datev_diktatkuerzel', autoBillingRuns: 'auto_billing_runs',
};
const sets: string[] = []; const params: unknown[] = [];
for (const [k, col] of Object.entries(cols)) if ((b as Record<string, unknown>)[k] !== undefined) { sets.push(`${col} = ?`); params.push((b as Record<string, unknown>)[k]); }
@ -256,6 +257,26 @@ export const invoicesModule: KcModule = {
return { overdueInvoices: overdue, dueContracts };
});
// ---- Abrechnungslauf (#50): Entwürfe je fälliger Vertragsperiode, jede Periode genau einmal ----------------
app.get('/invoices/billing-run/preview', async (req) => {
requirePermission(req, 'invoices.read');
return { periods: await duePeriods(), auto: await autoBillingEnabled() };
});
app.post('/invoices/billing-run', async (req) => {
const a = requirePermission(req, 'invoices.write');
const r = await runBilling(a.user.id);
await audit({ actorType: 'user', actorId: a.user.id, action: 'invoice.billing_run', resourceType: 'invoice', resourceId: 'run', correlationId: req.correlationId, ip: clientIp(req), after: { drafts: r.drafts.length, items: r.drafts.reduce((n, d) => n + d.items, 0), skipped: r.skipped } });
return r;
});
/** Storno einer Laufrechnung: Periode bleibt belegt, bis das Personal sie hier ausdrücklich zur erneuten Abrechnung freigibt. */
app.post('/invoices/:id/release-periods', async (req) => {
const a = requirePermission(req, 'invoices.write'); const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const n = await releaseCancelledPeriods(id);
if (n < 0) throw conflict('Nur Perioden stornierter Rechnungen können erneut abgerechnet werden.', 'INVOICE_NOT_CANCELLED');
await audit({ actorType: 'user', actorId: a.user.id, action: 'invoice.release_periods', resourceType: 'invoice', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), after: { periods: n } });
return { released: n };
});
app.post('/invoices', async (req) => {
const a = requirePermission(req, 'invoices.write');
const b = z.object({ orgId: z.string().uuid(), note: z.string().trim().max(500).optional(), paymentMethod: z.string().max(50).optional() }).parse(req.body);
@ -271,7 +292,8 @@ export const invoicesModule: KcModule = {
const staff = can(a.principal, 'invoices.read');
const res = await loadInvoice(id);
if (!res || !canInOrg(a.principal, res.v.org_id, 'invoices.read', 'invoices.read') || (!staff && res.v.status === 'draft')) throw notFound();
return { ...invoiceView(res.v), items: res.items.map(itemView), canWrite: staff };
const periods = staff ? await query('SELECT contract_id, period_start, period_end FROM invoice_billing_periods WHERE invoice_id = ? ORDER BY period_start', [id]) : [];
return { ...invoiceView(res.v), items: res.items.map(itemView), canWrite: staff, billingPeriods: periods.map((p) => ({ contractId: p.contract_id, start: p.period_start, end: p.period_end })) };
});
/** Ersetzt die Positionen eines Entwurfs vollständig (einfacher als Einzel-CRUD, ausreichend für eine Entwurfsphase). */
@ -284,6 +306,10 @@ export const invoicesModule: KcModule = {
if (v.status !== 'draft') throw conflict('Nur Entwürfe können bearbeitet werden. Ausgestellte Rechnungen sind unveränderlich (nur Storno möglich).', 'INVOICE_NOT_DRAFT');
let net = 0, tax = 0, gross = 0;
await tx(async (c) => {
// Status erst unter derselben Zeilensperre prüfen, die auch "Ausstellen" nimmt: sonst kann ein paralleles
// Ausstellen zwischen obiger Prüfung und dem Ersetzen gewinnen und die Positionen einer offenen Rechnung ändern.
const locked = await one('SELECT status FROM invoices WHERE id = ? FOR UPDATE', [id], c);
if (!locked || locked.status !== 'draft') throw conflict('Die Rechnung wurde inzwischen ausgestellt und ist unveränderlich (nur Storno möglich).', 'INVOICE_NOT_DRAFT');
await run('DELETE FROM invoice_items WHERE invoice_id = ?', [id], c);
for (const [idx, it] of b.items.entries()) {
const a2 = lineAmounts(it.unitPriceNetCents, it.quantity, it.taxBp, it.discountBp); net += a2.net; tax += a2.tax; gross += a2.gross;
@ -348,20 +374,24 @@ export const invoicesModule: KcModule = {
// IBAN, Steuernummer oder die Kundenanschrift, bleibt diese schon ausgestellte Rechnung unverändert, wie es sein muss.
const sellerSnap = { name: s.name, street: s.street, zip: s.zip, city: s.city, country: s.country, taxNumber: s.taxNumber, vatId: s.vatId, bankName: s.bankName, iban: s.iban, bic: s.bic, footerText: s.footerText };
const buyerSnap = { name: org?.company || org?.name || null, street: org?.street ?? null, zip: org?.zip ?? null, city: org?.city ?? null, country: org?.country ?? 'DE', vatId: org?.vat_id ?? null };
let issuedGross = Number(v.total_gross_cents);
const number = await tx(async (c) => {
// Zeile sperren statt nur zu lesen: verhindert, dass zwei gleichzeitige "Ausstellen"-Aufrufe beide eine Nummer
// ziehen (Nummernlücke) oder beide durchlaufen. Der Verlierer sieht nach dem Warten status≠'draft' und bricht ab,
// ohne je eine Nummer verbraucht zu haben.
const locked = await one('SELECT status FROM invoices WHERE id = ? FOR UPDATE', [id], c);
const locked = await one('SELECT status, total_gross_cents FROM invoices WHERE id = ? FOR UPDATE', [id], c);
if (!locked || locked.status !== 'draft') throw conflict('Die Rechnung wurde inzwischen von einem anderen Vorgang ausgestellt.', 'STALE_STATE');
// Positionen unter der Sperre erneut zählen (ein paralleles Speichern hat sie evtl. gerade ersetzt).
if (!(await one('SELECT 1 AS x FROM invoice_items WHERE invoice_id = ? LIMIT 1', [id], c))) throw badRequest('Eine Rechnung ohne Positionen kann nicht ausgestellt werden.', 'NO_ITEMS');
issuedGross = Number(locked.total_gross_cents);
const n = await nextInvoiceNumber(c, s.invoicePrefix);
await run("UPDATE invoices SET number = ?, status = 'open', issue_date = CURDATE(), due_date = ?, issued_at = UTC_TIMESTAMP(3), seller_snapshot_json = ?, buyer_snapshot_json = ? WHERE id = ?",
[n, due, JSON.stringify(sellerSnap), JSON.stringify(buyerSnap), id], c);
return n;
});
await audit({ actorType: 'user', actorId: a.user.id, orgId: v.org_id, action: 'invoice.issue', resourceType: 'invoice', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), after: { number } });
await notify('invoice.issued', { number, gross: v.total_gross_cents }, `invoice.issued:${id}`, req.correlationId);
if (org?.billing_email) await mailTo(org.billing_email, 'invoice_issued', { name: org.contact_name || org.company || org.name, number, amount: deMoney(v.total_gross_cents), dueDate: deDate(due), invoiceLink: `${config.baseUrl}/rechnungen/${id}` }, `mail:invoice.issued:${id}`, req.correlationId);
await notify('invoice.issued', { number, gross: issuedGross }, `invoice.issued:${id}`, req.correlationId);
if (org?.billing_email) await mailTo(org.billing_email, 'invoice_issued', { name: org.contact_name || org.company || org.name, number, amount: deMoney(issuedGross), dueDate: deDate(due), invoiceLink: `${config.baseUrl}/rechnungen/${id}` }, `mail:invoice.issued:${id}`, req.correlationId);
return { ok: true, number };
});

View file

@ -130,7 +130,7 @@ export const mailModule: KcModule = {
const params: unknown[] = [b.host, b.port, b.secureMode, b.username, b.folder, b.enabled ? 1 : 0, a.user.id];
if (b.password !== undefined) { sets.push('secrets_enc = ?'); params.push(b.password ? encrypt(JSON.stringify({ password: b.password })) : null); }
// Verbindungsdaten geändert: nächster Abruf beginnt wieder beim aktuellen Postfachstand (kein Bestand wird nachverarbeitet)
if (b.host || b.username || b.password) { sets.push('last_uid = NULL'); }
if (b.host || b.username || b.password) { sets.push('last_uid = NULL', 'uid_validity = NULL', 'failed_uid = NULL', 'failed_attempts = 0'); }
await run(`UPDATE imap_settings SET ${sets.join(', ')} WHERE id = 1`, params);
await audit({ actorType: 'user', actorId: a.user.id, action: 'email.imap.update', resourceType: 'imap_settings', resourceId: '1', correlationId: req.correlationId, ip: clientIp(req), after: { ...b, password: b.password !== undefined ? (b.password ? '***' : null) : undefined } });
return { ok: true };

View file

@ -14,16 +14,18 @@ import { clientIp, requireAuth, requirePermission, type AuthContext } from '../.
import { badRequest, conflict, forbidden, notFound } from '../../core/errors.js';
import { can, canInOrg } from '../../core/policy.js';
import type { KcModule } from '../../core/module.js';
import { domainQuote, normalizeDomain, splitDomain } from '@kc/platform/domains';
const j = (v: unknown, d: unknown = null) => (v == null ? d : typeof v === 'string' ? JSON.parse(v) : v);
async function nextNumber(c: PoolConnection, name: 'order' | 'contract', prefix: string): Promise<string> {
await run('UPDATE number_sequences SET next_value = LAST_INSERT_ID(next_value + 1) WHERE name = ?', [name], c);
return `${prefix}-${(await one('SELECT LAST_INSERT_ID() AS n', [], c))!.n}`;
}
const orderView = (o: any, items: any[] = []) => ({
const orderView = (o: any, items: any[] = [], domains: any[] = []) => ({
id: o.id, number: o.number, orgId: o.org_id, orgName: o.org_name, status: o.status, placedVia: o.placed_via, approvalRequired: !!o.approval_required, note: o.note,
failureNote: o.failure_note, failureAmbiguous: !!o.failure_ambiguous, createdAt: o.created_at, approvedAt: o.approved_at,
items: items.map((i) => ({ id: i.id, quantity: i.quantity, discountBp: i.discount_bp, snapshot: j(i.snapshot_json), contractId: i.contract_id ?? null, contractNumber: i.contract_number ?? null })),
domains: domains.map((d) => ({ domain: d.domain, termMonths: d.term_months, setupGrossCents: d.setup_gross_cents, sellNetCents: d.sell_net_cents, sellGrossCents: d.sell_gross_cents, taxBp: d.tax_bp, recorded: !!d.domain_record_id })),
});
const contractView = (c: any) => ({
id: c.id, number: c.number, orgId: c.org_id, orgName: c.org_name, status: c.status, productName: c.product_name, startedAt: c.started_at, termEnd: c.term_end, renewal: c.renewal, renewalTermMonths: c.renewal_term_months,
@ -34,7 +36,8 @@ async function loadOrder(id: string) {
const o = await one(`${ORDER_SQL} WHERE o.id = ?`, [id]);
if (!o) return null;
const items = await query('SELECT oi.*, c.id AS contract_id, c.number AS contract_number FROM order_items oi LEFT JOIN contracts c ON c.order_item_id = oi.id WHERE oi.order_id = ?', [id]);
return { o, items };
const domains = await query('SELECT * FROM order_domains WHERE order_id = ? ORDER BY domain', [id]);
return { o, items, domains };
}
const CONTRACT_SQL = `SELECT c.*, g.name AS org_name, JSON_VALUE(c.price_snapshot_json, '$.name') AS product_name FROM contracts c JOIN organizations g ON g.id = c.org_id`;
@ -45,6 +48,18 @@ async function orderEvent(c: PoolConnection | undefined, id: string, from: strin
if (!r.affectedRows) throw conflict('Die Bestellung wurde inzwischen geändert. Bitte neu laden.', 'STALE_STATE');
return to;
}
/** Freigegebene Domain-Positionen in die Domain-Aufstellung übernehmen (Beschaffung offen, Preis aus dem Bestell-Snapshot).
* Ist die Domain inzwischen anderweitig erfasst, bricht die Freigabe ab (409) statt still zu doppeln. */
async function materializeDomains(c: PoolConnection, orderId: string): Promise<void> {
const o = await one('SELECT org_id, number FROM orders WHERE id = ?', [orderId], c);
for (const d of await query('SELECT * FROM order_domains WHERE order_id = ? AND domain_record_id IS NULL', [orderId], c)) {
if (await one('SELECT 1 AS x FROM domain_records WHERE domain = ?', [d.domain], c)) throw conflict(`${d.domain} ist inzwischen bereits erfasst – bitte prüfen`, 'DOMAIN_EXISTS');
const q = j(d.snapshot_json); const rid = randomUUID();
await run("INSERT INTO domain_records (id, domain, tld, org_id, source, term_months, cost_net_cents, cost_gross_cents, setup_cost_cents, sell_net_cents, tax_bp, sell_gross_cents, procurement, note, priced_at) VALUES (?,?,?,?, 'manual', ?,?,?,?,?,?,?, 'open', ?, UTC_TIMESTAMP(3))",
[rid, d.domain, d.tld, o!.org_id, d.term_months, q.costNet, q.costGross, d.setup_gross_cents, d.sell_net_cents, d.tax_bp, d.sell_gross_cents, `Bestellung ${o!.number}`], c);
await run('UPDATE order_domains SET domain_record_id = ? WHERE id = ?', [rid, d.id], c);
}
}
const startProvisioning = (orderId: string, key: string, correlationId: string) => enqueue('order.provision', { orderId }, { idempotencyKey: key, correlationId });
const orderAccess = (a: AuthContext, orgId: string) => canInOrg(a.principal, orgId, 'orders.read', 'orders.read');
@ -61,7 +76,7 @@ export const ordersModule: KcModule = {
// ---- Bestellung anlegen ------------------------------------------------
app.post('/orders', async (req) => {
const a = requireAuth(req);
const b = z.object({ orgId: z.string().uuid(), note: z.string().trim().max(500).optional(), items: z.array(z.object({ productId: z.string().uuid(), quantity: z.number().int().min(1).max(100).default(1), discountBp: z.number().int().min(0).max(10000).default(0), termMonths: z.number().int().min(1).max(120).optional() })).min(1).max(20) }).parse(req.body);
const b = z.object({ orgId: z.string().uuid(), note: z.string().trim().max(500).optional(), items: z.array(z.object({ productId: z.string().uuid(), quantity: z.number().int().min(1).max(100).default(1), discountBp: z.number().int().min(0).max(10000).default(0), termMonths: z.number().int().min(1).max(120).optional() })).min(1).max(20), domains: z.array(z.object({ name: z.string().trim().min(3).max(253) })).max(10).default([]) }).parse(req.body);
const staff = can(a.principal, 'orders.write');
if (!canInOrg(a.principal, b.orgId, 'orders.create', 'orders.write')) { if (!canInOrg(a.principal, b.orgId, 'orders.read', 'orders.read')) throw notFound(); throw forbidden(); }
const org = await one('SELECT id, status, customer_type FROM organizations WHERE id = ?', [b.orgId]);
@ -90,7 +105,22 @@ export const ordersModule: KcModule = {
if (org.customer_type === 'private' && terms.renewal === 'auto') terms = { ...terms, ...consumerTerms(terms.renewalTermMonths, terms.noticeDays) }; // Verbraucherregel, rechtlich zu prüfen
lines.push({ p, it, snapshot: { productId: p.id, sku: p.sku, productVersionId: p.vid, version: p.version, name: p.vname, category: p.category, customerType: org.customer_type, ...price, terms } });
}
const approvalRequired = !staff && lines.some((l) => !!l.p.requires_approval); // Personal bestellt = freigegeben
// Domains als eigene Positionen (#80): Preis und Laufzeit IMMER serverseitig aus der Domain-Preisliste; ohne
// Verkaufspreis (kein Aufschlag festgelegt) keine Bestellung – nie eine 0-Euro-Domain.
const domainLines: { name: string; tld: string; q: Awaited<ReturnType<typeof domainQuote>> }[] = [];
if (b.domains.length) {
const known = new Set((await query('SELECT tld FROM domain_tlds WHERE active = 1')).map((r) => String(r.tld)));
for (const d of b.domains) {
const name = normalizeDomain(d.name); const sp = name ? splitDomain(name, known) : null;
if (!name || !sp) throw badRequest(`„${d.name}“ ist keine gültige Domain mit angebotener Endung`, 'DOMAIN_INVALID');
if (domainLines.some((x) => x.name === name)) throw badRequest(`${name} ist doppelt angegeben`, 'DOMAIN_DUPLICATE');
if (await one('SELECT 1 AS x FROM domain_records WHERE domain = ?', [name])) throw conflict(`${name} ist bereits erfasst`, 'DOMAIN_EXISTS');
const q = await domainQuote(sp.tld);
if (q.net === null || q.gross === null || !q.termMonths) throw badRequest(`Für .${sp.tld} gibt es derzeit keinen Verkaufspreis – bitte beim Support anfragen`, 'DOMAIN_NO_PRICE');
domainLines.push({ name, tld: sp.tld, q });
}
}
const approvalRequired = !staff && (lines.some((l) => !!l.p.requires_approval) || domainLines.length > 0); // Domains prüft immer das Personal (Verfügbarkeit erst beim Registrar sicher)
const orderId = randomUUID();
const number = await tx(async (c) => {
const n = await nextNumber(c, 'order', 'B');
@ -102,10 +132,12 @@ export const ordersModule: KcModule = {
await run("INSERT INTO contracts (id, number, org_id, order_item_id, product_version_id, status, renewal, renewal_term_months, notice_days, price_snapshot_json) VALUES (?,?,?,?,?,'pending',?,?,?,?)",
[randomUUID(), await nextNumber(c, 'contract', 'V'), b.orgId, itemId, l.snapshot.productVersionId, l.snapshot.terms.renewal, l.snapshot.terms.renewalTermMonths, l.snapshot.terms.noticeDays, JSON.stringify(l.snapshot)], c);
}
if (!approvalRequired) { await orderEvent(c, orderId, 'approved', 'start_provisioning'); await startProvisioning(orderId, `provision:${orderId}:1`, req.correlationId); }
for (const d of domainLines) await run('INSERT INTO order_domains (id, order_id, domain, tld, term_months, setup_gross_cents, sell_net_cents, sell_gross_cents, tax_bp, snapshot_json) VALUES (?,?,?,?,?,?,?,?,?,?)',
[randomUUID(), orderId, d.name, d.tld, d.q.termMonths, d.q.setup, d.q.net, d.q.gross, d.q.tax, JSON.stringify(d.q)], c);
if (!approvalRequired) { await materializeDomains(c, orderId); await orderEvent(c, orderId, 'approved', 'start_provisioning'); await startProvisioning(orderId, `provision:${orderId}:1`, req.correlationId); }
return n;
});
await audit({ actorType: 'user', actorId: a.user.id, orgId: b.orgId, action: 'order.create', resourceType: 'order', resourceId: orderId, correlationId: req.correlationId, ip: clientIp(req), after: { number, approvalRequired, items: lines.map((l) => ({ sku: l.snapshot.sku, quantity: l.it.quantity, discountBp: l.it.discountBp })) } });
await audit({ actorType: 'user', actorId: a.user.id, orgId: b.orgId, action: 'order.create', resourceType: 'order', resourceId: orderId, correlationId: req.correlationId, ip: clientIp(req), after: { number, approvalRequired, items: lines.map((l) => ({ sku: l.snapshot.sku, quantity: l.it.quantity, discountBp: l.it.discountBp })), domains: domainLines.map((d) => d.name) } });
return { id: orderId, number, status: approvalRequired ? 'pending_approval' : 'provisioning' };
});
@ -126,7 +158,7 @@ export const ordersModule: KcModule = {
const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const r = await loadOrder(id);
if (!r || !orderAccess(a, r.o.org_id)) throw notFound();
return orderView(r.o, r.items);
return orderView(r.o, r.items, r.domains);
});
// ---- Freigabe, Ablehnung, Storno, Wiederholung -------------------------
@ -134,7 +166,7 @@ export const ordersModule: KcModule = {
const a = requirePermission(req, 'orders.approve');
const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const r = await loadOrder(id); if (!r) throw notFound();
await tx(async (c) => { await orderEvent(c, id, r.o.status, 'approve', { sql: 'approved_by = ?, approved_at = ?', params: [a.user.id, new Date()] }); await orderEvent(c, id, 'approved', 'start_provisioning'); await startProvisioning(id, `provision:${id}:1`, req.correlationId); });
await tx(async (c) => { await orderEvent(c, id, r.o.status, 'approve', { sql: 'approved_by = ?, approved_at = ?', params: [a.user.id, new Date()] }); await materializeDomains(c, id); await orderEvent(c, id, 'approved', 'start_provisioning'); await startProvisioning(id, `provision:${id}:1`, req.correlationId); });
await audit({ actorType: 'user', actorId: a.user.id, orgId: r.o.org_id, action: 'order.approve', resourceType: 'order', resourceId: id, correlationId: req.correlationId, ip: clientIp(req) });
return { status: 'provisioning' };
});

View file

@ -1,12 +1,12 @@
import type { FastifyInstance } from 'fastify';
import { z } from 'zod';
import { randomUUID, createHash } from 'node:crypto';
import { randomUUID, createHash, createHmac, timingSafeEqual } from 'node:crypto';
import { domainToUnicode } from 'node:url';
import { ACTION_CAPABILITY, ACTIONS, loadInstance, type ActionName } from '@kc/connectors';
import { ConnectorError, type ChildKind } from '@kc/connector-sdk';
import { decrypt, encrypt, randomToken } from '../../core/crypto.js';
import { CHILD_MANAGE, CUSTOMER_ACTIONS } from '../../core/actions.js';
import { rl } from '../../core/config.js';
import { config, rl } from '../../core/config.js';
import { DESTRUCTIVE_ACTIONS } from '@kc/connector-sdk';
import { one, query, run } from '../../core/db.js';
import { audit } from '../../core/audit.js';
@ -16,8 +16,26 @@ import { clientIp, requireAuth, requirePermission, type AuthContext } from '../.
import { AppError, badRequest, forbidden, notFound } from '../../core/errors.js';
import { can, canInOrg } from '../../core/policy.js';
import type { KcModule } from '../../core/module.js';
import { findDrift } from '@kc/platform/drift';
const STALE_FACTOR = 3;
/** Apple-Profil-Links: KeyHelp liefert das Profil nur per http → das Kundencenter reicht es per https durch. Signiertes Token, 24 h gültig, ohne Anmeldung (QR-Scan am Handy). */
const PROFILE_TTL_SEC = 24 * 3600;
const profileSig = (body: string) => createHmac('sha256', config.secretKey).update(`mail-profile:${body}`).digest('base64url');
const profileLink = (resourceId: string, childId: string, protocol: string) => {
const body = Buffer.from(JSON.stringify({ r: resourceId, c: childId, p: protocol, x: Math.floor(Date.now() / 1000) + PROFILE_TTL_SEC })).toString('base64url');
return `${config.baseUrl}/api/mail-profile?t=${body}.${profileSig(body)}`; // Query statt Pfad: Fastify begrenzt Pfadparameter auf 100 Zeichen
};
function readProfileToken(token: string): { r: string; c: string; p: 'imap' | 'pop3' } | null {
const [body, sig] = token.split('.'); if (!body || !sig) return null;
const want = Buffer.from(profileSig(body)); const got = Buffer.from(sig);
if (want.length !== got.length || !timingSafeEqual(want, got)) return null;
try {
const t = z.object({ r: z.string().uuid(), c: z.string().min(1).max(40), p: z.enum(['imap', 'pop3']), x: z.number().int() }).parse(JSON.parse(Buffer.from(body, 'base64url').toString('utf8')));
return t.x * 1000 > Date.now() ? t : null;
} catch { return null; }
}
const KEYHELP_PROFILE = /^http:\/\/autoconfig-apple\.[a-z0-9.-]{1,253}\/setup\.mobileconfig\?email=[^&\s]{3,400}&protocol=(imap|pop3)$/;
const json = <T>(v: unknown, d: T): T => (v == null ? d : typeof v === 'string' ? JSON.parse(v) : (v as T));
/** Ressource + Instanzzustand; "stale" = Provider gestört oder Daten älter als 3 Abgleichintervalle. */
@ -201,12 +219,12 @@ export const resourcesModule: KcModule = {
});
// ---- Hosting: Unterobjekte (Domains, Postfächer, Datenbanken, FTP, SSL) und Panel-Login ----------
const KINDS = ['domain', 'email', 'database', 'ftp', 'certificate'] as const;
const KINDS = ['domain', 'email', 'database', 'ftp', 'certificate', 'dns', 'dirprotect'] as const;
const kindParam = z.object({ id: z.string().uuid(), kind: z.enum(KINDS) });
const childCaps = (r: any): string[] => json<string[]>(r.capabilities_json, []);
/** Schreiben erlaubt: Personal mit Schreibrecht ODER Inhaber/Admin der Organisation, wenn das Produkt es für diese Art freigibt. */
const canManageKind = (r: any, a: AuthContext, kind: string): boolean => {
if (kind === 'certificate') return false;
if (kind === 'certificate' || kind === 'dns' || kind === 'dirprotect') return false; // nur lesend (#74)
if (r.health !== 'ok' || !r.enabled || !childCaps(r).includes('children.write')) return false;
if (can(a.principal, 'resources.write')) return true;
const need = CHILD_MANAGE[kind];
@ -234,6 +252,37 @@ export const resourcesModule: KcModule = {
try { const { connector, ctx } = await loadInstance(r.instance_id, req.correlationId); return await connector.children!.list(ctx, r.external_ref, kind as ChildKind); }
catch (e) { return providerError(e); }
});
/** Verbindungsdaten eines Postfachs (Server, Ports, Einrichtungsprofile) – lesend, ohne Passwort; wer die Postfächer sehen darf, darf auch das. */
app.get('/resources/:id/children/:kind/:childId/connection', { config: rl(60, '1 minute') }, async (req) => {
const a = requireAuth(req);
const { id, kind, childId } = kindParam.extend({ childId: z.string().min(1).max(40) }).parse(req.params);
const r = await loadResource(id);
if (!r || !access(a, r) || !childCaps(r).includes('children.read') || kind !== 'email') throw notFound();
try {
const { connector, ctx } = await loadInstance(r.instance_id, req.correlationId);
if (!connector.children?.connectionInfo) throw notFound();
const info = await connector.children.connectionInfo(ctx, { parentRef: r.external_ref, kind, id: childId });
return { ...info, profiles: info.profiles.map((p) => ({ ...p, url: profileLink(id, childId, p.protocol) })) };
} catch (e) { return providerError(e); }
});
/** Öffentlich (Token statt Anmeldung): holt das Apple-Profil beim Anbieter und liefert es per https aus. */
app.get('/mail-profile', { config: rl(30, '1 minute') }, async (req, reply) => {
const { t: token } = z.object({ t: z.string().min(10).max(600) }).parse(req.query);
const t = readProfileToken(token); if (!t) throw new AppError(404, 'LINK_INVALID', 'Der Link ist ungültig oder abgelaufen. Bitte die Verbindungsdaten im Kundencenter neu öffnen.');
const r = await loadResource(t.r);
if (!r || !r.enabled || !childCaps(r).includes('children.read')) throw notFound();
let src: string | undefined;
try {
const { connector, ctx } = await loadInstance(r.instance_id, req.correlationId);
if (!connector.children?.connectionInfo) throw notFound();
src = (await connector.children.connectionInfo(ctx, { parentRef: r.external_ref, kind: 'email', id: t.c })).profiles.find((p) => p.protocol === t.p)?.url;
} catch (e) { return providerError(e); }
if (!src || !KEYHELP_PROFILE.test(src)) throw notFound();
const res = await fetch(src, { redirect: 'error', signal: AbortSignal.timeout(10_000) }).catch(() => null);
const buf = res?.ok ? Buffer.from(await res.arrayBuffer()) : null;
if (!buf || buf.length > 256_000 || !buf.includes('PayloadContent')) throw new AppError(502, 'CONNECTOR_ERROR', 'Das Einrichtungsprofil konnte nicht geladen werden.');
return reply.header('content-type', 'application/x-apple-aspen-config').header('content-disposition', `attachment; filename="${t.p}.mobileconfig"`).header('cache-control', 'no-store').send(buf);
});
/** Änderung an einem Unterobjekt: läuft als persistenter Auftrag; Passwörter nur verschlüsselt im Auftrag, nach der Ausführung entfernt. */
app.post('/resources/:id/children/:kind', { config: rl(30, '1 minute') }, async (req, reply) => {
const a = requireAuth(req);
@ -272,7 +321,7 @@ export const resourcesModule: KcModule = {
if (!r || !access(a, r)) throw notFound();
if (!canLogin(r, a)) throw forbidden('Der Panel-Login ist für diese Ressource nicht möglich', 'LOGIN_FORBIDDEN');
let out: { url: string; validForSec: number };
try { const { connector, ctx } = await loadInstance(r.instance_id, req.correlationId); out = await connector.loginUrl!(ctx, r.external_ref); } catch (e) { return providerError(e); }
try { const { connector, ctx } = await loadInstance(r.instance_id, req.correlationId); out = await connector.loginUrl!(ctx, r.external_ref, { userIp: clientIp(req) }); } catch (e) { return providerError(e); }
await audit({ actorType: 'user', actorId: a.user.id, orgId: r.org_id, action: 'resource.login', resourceType: 'resource', resourceId: id, connector: r.connector_key, correlationId: req.correlationId, ip: clientIp(req) });
reply.header('cache-control', 'no-store'); return out;
});
@ -287,6 +336,11 @@ export const resourcesModule: KcModule = {
return { id: j.id, status: j.status, attempts: j.attempts, maxAttempts: j.max_attempts, error: j.last_error, createdAt: j.created_at, updatedAt: j.updated_at };
});
/** Soll-Ist-Abweichungen Vertrag ↔ Anbieter (#21). Nur Anzeige – Korrekturen bewusst über die normalen Aktionen. */
app.get('/admin/drift', async (req) => {
requirePermission(req, 'resources.read');
return findDrift();
});
app.get('/admin/jobs', async (req) => {
requirePermission(req, 'jobs.read');
const q = z.object({ status: z.string().max(30).optional() }).parse(req.query);

View file

@ -0,0 +1,78 @@
import type { FastifyInstance } from 'fastify';
import { z } from 'zod';
import { randomUUID } from 'node:crypto';
import { one, query, run, tx } from '../../core/db.js';
import { audit } from '../../core/audit.js';
import { clientIp, requirePermission } from '../../core/auth.js';
import { badRequest, notFound } from '../../core/errors.js';
import { rl } from '../../core/config.js';
import type { KcModule } from '../../core/module.js';
/**
* Öffentliche Statusseite (#23). Wartungen und Vorfälle werden vom Personal angelegt und erst mit „veröffentlichen“
* öffentlich sichtbar. Die öffentliche Ausgabe enthält nur die vom Personal geschriebenen Texte (Titel, Bereich,
* Meldungen) – nie Kunden-, Ressourcen- oder Anbieterdaten und nichts aus den internen Betriebsalarmen.
*/
const OPEN_STATES = ['planned', 'investigating', 'identified', 'monitoring', 'in_progress'];
const STATE = { incident: ['investigating', 'identified', 'monitoring', 'resolved'], maintenance: ['planned', 'in_progress', 'completed'] } as const;
const view = (e: any, updates: any[], admin = false) => ({
...(admin ? { published: !!e.published } : {}),
id: e.id, kind: e.kind, title: e.title, component: e.component, impact: e.impact, state: e.state, startsAt: e.starts_at, endsAt: e.ends_at,
updates: updates.filter((u) => u.event_id === e.id).map((u) => ({ state: u.state, body: u.body, at: u.created_at })),
});
async function withUpdates(events: any[], admin = false) {
if (!events.length) return [];
const ups = await query(`SELECT event_id, state, body, created_at FROM status_updates WHERE event_id IN (${events.map(() => '?').join(',')}) ORDER BY created_at DESC`, events.map((e) => e.id));
return events.map((e) => view(e, ups, admin));
}
export const statusModule: KcModule = {
name: 'status',
permissions: { staff: { support: ['status.read', 'status.write'], admin: ['status.read', 'status.write'], superadmin: ['status.read', 'status.write'] } },
register(app: FastifyInstance) {
/** Öffentlich, ohne Anmeldung. */
app.get('/public/status', { config: rl(60, '1 minute') }, async () => {
const current = await query(`SELECT * FROM status_events WHERE published = 1 AND state IN (${OPEN_STATES.map(() => '?').join(',')}) ORDER BY starts_at`, OPEN_STATES);
const recent = await query("SELECT * FROM status_events WHERE published = 1 AND state IN ('resolved','completed') AND COALESCE(ends_at, updated_at) > DATE_SUB(UTC_TIMESTAMP(3), INTERVAL 14 DAY) ORDER BY COALESCE(ends_at, updated_at) DESC LIMIT 20");
const now = Date.now();
const active = current.filter((e) => e.kind === 'incident' || new Date(e.starts_at).getTime() <= now);
const overall = active.some((e) => e.impact === 'major') ? 'major' : active.some((e) => e.impact === 'minor') ? 'minor' : active.length ? 'maintenance' : 'ok';
return { overall, current: await withUpdates(current), recent: await withUpdates(recent), generatedAt: new Date().toISOString() };
});
app.get('/admin/status-events', async (req) => {
requirePermission(req, 'status.read');
return withUpdates(await query('SELECT * FROM status_events ORDER BY starts_at DESC LIMIT 100'), true);
});
app.post('/admin/status-events', async (req) => {
const a = requirePermission(req, 'status.write');
const b = z.object({ kind: z.enum(['incident', 'maintenance']), title: z.string().trim().min(3).max(200), component: z.string().trim().max(100).optional(),
impact: z.enum(['none', 'minor', 'major']).default('minor'), startsAt: z.coerce.date().optional(), endsAt: z.coerce.date().optional(), body: z.string().trim().min(3).max(2000), published: z.boolean().default(false) }).parse(req.body);
if (b.endsAt && b.startsAt && b.endsAt < b.startsAt) throw badRequest('Das Ende liegt vor dem Beginn', 'BAD_RANGE');
const id = randomUUID(); const state = b.kind === 'incident' ? 'investigating' : 'planned';
await tx(async (c) => {
await run('INSERT INTO status_events (id, kind, title, component, impact, state, starts_at, ends_at, published, created_by) VALUES (?,?,?,?,?,?,?,?,?,?)',
[id, b.kind, b.title, b.component ?? null, b.impact, state, b.startsAt ?? new Date(), b.endsAt ?? null, b.published ? 1 : 0, a.user.id], c);
await run('INSERT INTO status_updates (id, event_id, state, body, created_by) VALUES (?,?,?,?,?)', [randomUUID(), id, state, b.body, a.user.id], c);
});
await audit({ actorType: 'user', actorId: a.user.id, action: 'status.create', resourceType: 'status_event', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), after: { kind: b.kind, published: b.published } });
return { id };
});
/** Neuer Stand (Meldung) und/oder Veröffentlichung ändern. */
app.post('/admin/status-events/:id/update', async (req) => {
const a = requirePermission(req, 'status.write');
const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const b = z.object({ state: z.string().max(30).optional(), body: z.string().trim().min(3).max(2000).optional(), published: z.boolean().optional(), impact: z.enum(['none', 'minor', 'major']).optional(), endsAt: z.coerce.date().optional() }).parse(req.body);
const e = await one('SELECT * FROM status_events WHERE id = ?', [id]); if (!e) throw notFound();
if (b.state && !(STATE[e.kind as 'incident' | 'maintenance'] as readonly string[]).includes(b.state)) throw badRequest('Dieser Zustand passt nicht zur Art des Eintrags', 'BAD_STATE');
const closing = b.state === 'resolved' || b.state === 'completed';
await tx(async (c) => {
await run('UPDATE status_events SET state = COALESCE(?, state), published = COALESCE(?, published), impact = COALESCE(?, impact), ends_at = COALESCE(?, IF(?, UTC_TIMESTAMP(3), ends_at)) WHERE id = ?',
[b.state ?? null, b.published === undefined ? null : b.published ? 1 : 0, b.impact ?? null, b.endsAt ?? null, closing ? 1 : 0, id], c);
if (b.body) await run('INSERT INTO status_updates (id, event_id, state, body, created_by) VALUES (?,?,?,?,?)', [randomUUID(), id, b.state ?? e.state, b.body, a.user.id], c);
});
await audit({ actorType: 'user', actorId: a.user.id, action: 'status.update', resourceType: 'status_event', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), after: { state: b.state, published: b.published } });
return { ok: true };
});
},
};

View file

@ -4,6 +4,7 @@ import { requirePermission } from '../../core/auth.js';
import { query } from '../../core/db.js';
import { readFile } from 'node:fs/promises';
import type { KcModule } from '../../core/module.js';
import { activeAlerts, ALERT_LABEL, heartbeatAgeMs } from '@kc/platform/monitor';
/** Backup-Zustand aus der Statusdatei des Backup-Laufs (siehe docs/betrieb-backup-restore.md). Ohne Datei: nicht eingerichtet. */
async function backupState() {
@ -29,7 +30,10 @@ export const systemModule: KcModule = {
requirePermission(req, 'jobs.read');
const jobs = await query('SELECT status, COUNT(*) AS n FROM jobs GROUP BY status');
const oldest = await one('SELECT MIN(run_at) AS t FROM jobs WHERE status IN (\'scheduled\',\'retrying\')');
return { jobs: Object.fromEntries(jobs.map((j) => [j.status, Number(j.n)])), oldestPendingJob: oldest?.t ?? null, serverTime: new Date().toISOString(), backup: await backupState() };
const workerAge = await heartbeatAgeMs('worker');
const alerts = (await activeAlerts()).map((a) => ({ ...a, label: ALERT_LABEL[a.key] ?? a.key }));
return { jobs: Object.fromEntries(jobs.map((j) => [j.status, Number(j.n)])), oldestPendingJob: oldest?.t ?? null, serverTime: new Date().toISOString(), backup: await backupState(),
worker: { lastHeartbeatSecondsAgo: workerAge === null ? null : Math.round(workerAge / 1000) }, alerts };
});
},
};

View file

@ -13,6 +13,8 @@ import { can, canInOrg } from '../../core/policy.js';
import type { KcModule } from '../../core/module.js';
import { config } from '../../core/config.js';
import { MAX_FILES_PER_MESSAGE, MAX_FILE_BYTES, pathFor, storeUpload } from './files.js';
import { TICKET_PERMISSIONS } from '@kc/platform/ticketPolicy';
const mutable = <T extends Record<string, readonly string[]>>(m: T) => Object.fromEntries(Object.entries(m).map(([k, v]) => [k, [...v]])) as { [K in keyof T]: string[] };
const ticketLink = (id: string) => `${config.baseUrl}/tickets/${id}`;
@ -33,7 +35,7 @@ const TICKET_SQL = `SELECT t.*, g.name AS org_name, g.customer_number, u.name AS
const messageView = (m: any, atts: any[] = []) => ({ id: m.id, authorId: m.author_id, authorName: m.author_name, authorKind: m.author_kind, body: m.body, internalNote: !!m.internal_note, createdAt: m.created_at,
attachments: atts.filter((a) => a.message_id === m.id).map((a) => ({ id: a.id, filename: a.filename, contentType: a.content_type, sizeBytes: a.size_bytes })) });
const notify = (event: string, extra: Record<string, unknown>, key: string, correlationId: string) => enqueue('discord.notify', { event, ...extra }, { idempotencyKey: key, correlationId });
const mailTo = (to: string, template: string, vars: Record<string, string>, key: string, correlationId: string) => enqueue('mail.template', { to, key: template, vars }, { idempotencyKey: key, correlationId });
const mailTo = (to: string, template: string, vars: Record<string, string>, key: string, correlationId: string, replyTicketId?: string) => enqueue('mail.template', { to, key: template, vars, replyTicketId }, { idempotencyKey: key, correlationId });
/** Meldet neue Nachrichten/Status auf CUSTOMER-sichtbare Zeilen; interne Notizen werden für Kunden ausgefiltert. */
async function loadTicket(id: string, forCustomer: boolean) {
@ -47,10 +49,7 @@ async function loadTicket(id: string, forCustomer: boolean) {
export const ticketsModule: KcModule = {
name: 'tickets',
permissions: {
staff: { support: ['tickets.read', 'tickets.write'], accounting: ['tickets.read'], admin: ['tickets.read', 'tickets.write'], superadmin: ['tickets.read', 'tickets.write'] },
org: { owner: ['tickets.read', 'tickets.create'], admin: ['tickets.read', 'tickets.create'], member: ['tickets.read', 'tickets.create'] },
},
permissions: { staff: mutable(TICKET_PERMISSIONS.staff), org: mutable(TICKET_PERMISSIONS.org) }, // gemeinsame Quelle mit dem Discord-Worker
register(app: FastifyInstance) {
app.post('/tickets', async (req) => {
const a = requireAuth(req);
@ -72,7 +71,7 @@ export const ticketsModule: KcModule = {
await audit({ actorType: 'user', actorId: a.user.id, orgId: b.orgId, action: 'ticket.create', resourceType: 'ticket', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), after: { number, subject: b.subject } });
if (!staff) {
await notify('ticket.created', { number, subject: b.subject.slice(0, 100) }, `ticket.created:${id}`, req.correlationId);
await mailTo(a.user.email, 'ticket_created', { name: a.user.name, number, subject: b.subject, ticketLink: ticketLink(id) }, `mail:ticket.created:${id}`, req.correlationId);
await mailTo(a.user.email, 'ticket_created', { name: a.user.name, number, subject: b.subject, ticketLink: ticketLink(id) }, `mail:ticket.created:${id}`, req.correlationId, id);
await enqueue('discord.ticket_sync', { ticketId: id, body: b.body, authorLabel: 'Kunde' }, { idempotencyKey: `discord:ticket.created:${id}`, correlationId: req.correlationId });
}
return { id, number, messageId };
@ -123,7 +122,7 @@ export const ticketsModule: KcModule = {
let emailed = false;
if (!b.internalNote && staff && b.notifyEmail) {
const creator = await one('SELECT email, name FROM users WHERE id = ?', [t.created_by]);
if (creator) { await mailTo(creator.email, 'ticket_message', { name: creator.name, number: t.number, subject: t.subject, ticketLink: ticketLink(id) }, `mail:ticket.message:${id}:${Date.now()}`, req.correlationId); emailed = true; }
if (creator) { await mailTo(creator.email, 'ticket_message', { name: creator.name, number: t.number, subject: t.subject, ticketLink: ticketLink(id) }, `mail:ticket.message:${id}:${Date.now()}`, req.correlationId, id); emailed = true; }
}
return { ok: true, messageId, emailed };
});
@ -164,7 +163,8 @@ export const ticketsModule: KcModule = {
const t = await one('SELECT * FROM tickets WHERE id = ?', [id]); if (!t || !canInOrg(a.principal, t.org_id, 'tickets.read', 'tickets.read')) throw notFound();
const att = await one('SELECT ta.*, m.internal_note FROM ticket_attachments ta JOIN ticket_messages m ON m.id = ta.message_id WHERE ta.id = ? AND ta.ticket_id = ?', [attachmentId, id]);
if (!att || (att.internal_note && !staff)) throw notFound();
reply.header('content-type', att.content_type).header('content-disposition', `inline; filename="${encodeURIComponent(att.filename)}"`).header('cache-control', 'private, max-age=3600');
reply.header('content-type', att.content_type).header('content-disposition', `inline; filename="${encodeURIComponent(att.filename)}"`).header('cache-control', 'private, max-age=3600')
.header('x-content-type-options', 'nosniff'); // Typ ist serverseitig per Signatur geprüft (nur Bilder/PDF); Browser soll nicht raten
return reply.send(createReadStream(pathFor(id, att.id, att.content_type)));
});
@ -195,29 +195,35 @@ export const ticketsModule: KcModule = {
});
// ---- Posteingang: eingehende Mails, die der IMAP-Abruf keinem Ticket zuordnen konnte -----------
const inboxView = (m: any) => ({ id: m.id, fromEmail: m.from_email, fromName: m.from_name, subject: m.subject, bodyText: m.body_text, receivedAt: m.received_at, status: m.status, ticketId: m.ticket_id, ticketNumber: m.ticket_number ?? null });
// suggested*: nur Hinweise aus Betreff/Absender (fälschbar) – das Personal entscheidet, automatisch wird nichts zugeordnet (#107)
const inboxView = (m: any) => ({ id: m.id, fromEmail: m.from_email, fromName: m.from_name, subject: m.subject, bodyText: m.body_text, receivedAt: m.received_at, status: m.status, ticketId: m.ticket_id, ticketNumber: m.ticket_number ?? null,
suggestedTicketNumber: m.suggested_ticket_number ?? null, suggestedOrgId: m.suggested_org_id ?? null, processingError: m.processing_error ?? null });
app.get('/admin/inbox', async (req) => {
requirePermission(req, 'tickets.read');
const q = z.object({ status: z.enum(['unmatched', 'matched', 'created', 'ignored']).optional() }).parse(req.query);
const rows = await query('SELECT im.*, t.number AS ticket_number FROM inbox_messages im LEFT JOIN tickets t ON t.id = im.ticket_id WHERE (? IS NULL OR im.status = ?) ORDER BY im.received_at DESC LIMIT 200', [q.status ?? null, q.status ?? null]);
const rows = await query(`SELECT im.*, t.number AS ticket_number, st.number AS suggested_ticket_number,
(SELECT m.org_id FROM memberships m WHERE m.user_id = im.suggested_user_id ORDER BY (m.role = 'owner') DESC LIMIT 1) AS suggested_org_id
FROM inbox_messages im LEFT JOIN tickets t ON t.id = im.ticket_id LEFT JOIN tickets st ON st.id = im.suggested_ticket_id
WHERE (? IS NULL OR im.status = ?) ORDER BY im.received_at DESC LIMIT 200`, [q.status ?? null, q.status ?? null]);
return rows.map(inboxView);
});
/** Unbekannter Absender wird einem Kunden zugeordnet: neues Ticket, Autor ist der (erste) Ansprechpartner des Kunden. */
app.post('/admin/inbox/:id/assign', async (req) => {
const a = requirePermission(req, 'tickets.write'); const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const b = z.object({ orgId: z.string().uuid() }).parse(req.body);
const msg = await one('SELECT * FROM inbox_messages WHERE id = ?', [id]); if (!msg) throw notFound();
if (msg.status !== 'unmatched') throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED');
const owner = await one("SELECT user_id FROM memberships WHERE org_id = ? ORDER BY (role = 'owner') DESC LIMIT 1", [b.orgId]);
if (!owner) throw badRequest('Für diesen Kunden ist kein Ansprechpartner hinterlegt.', 'NO_MEMBER');
const ticketId = randomUUID();
const number = await tx(async (c) => {
// Status unter Zeilensperre prüfen und im selben Schritt setzen: zwei gleichzeitige Klicks erzeugen kein zweites Ticket
const { number, msg } = await tx(async (c) => {
const msg = await one('SELECT * FROM inbox_messages WHERE id = ? FOR UPDATE', [id], c); if (!msg) throw notFound();
if (msg.status !== 'unmatched') throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED');
const n = await nextNumber(c);
await run('INSERT INTO tickets (id, number, org_id, subject, status, priority, created_by) VALUES (?,?,?,?,?,?,?)', [ticketId, n, b.orgId, msg.subject || '(kein Betreff)', 'pending_staff', 'normal', owner.user_id], c);
await run('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), ticketId, owner.user_id, 'customer', msg.body_text || '(kein Text)'], c);
return n;
await run("UPDATE inbox_messages SET status = 'created', ticket_id = ? WHERE id = ?", [ticketId, id], c);
return { number: n, msg };
});
await run("UPDATE inbox_messages SET status = 'created', ticket_id = ? WHERE id = ?", [ticketId, id]);
await audit({ actorType: 'user', actorId: a.user.id, orgId: b.orgId, action: 'inbox.assign', resourceType: 'inbox_message', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), after: { ticketId, number } });
await notify('ticket.created', { number, subject: (msg.subject || '').slice(0, 100) }, `mail-in-assign:${id}`, req.correlationId);
return { ticketId, number };
@ -226,21 +232,22 @@ export const ticketsModule: KcModule = {
app.post('/admin/inbox/:id/link', async (req) => {
const a = requirePermission(req, 'tickets.write'); const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const b = z.object({ ticketNumber: z.string().trim().min(1).max(20) }).parse(req.body);
const msg = await one('SELECT * FROM inbox_messages WHERE id = ?', [id]); if (!msg) throw notFound();
if (msg.status !== 'unmatched') throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED');
const t = await one('SELECT * FROM tickets WHERE number = ?', [b.ticketNumber]); if (!t) throw badRequest('Ticket nicht gefunden.', 'TICKET_NOT_FOUND');
await run('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), t.id, t.created_by, 'customer', msg.body_text || '(kein Text)']);
await run("UPDATE tickets SET status = 'pending_staff', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [t.id]);
await run("UPDATE inbox_messages SET status = 'matched', ticket_id = ? WHERE id = ?", [t.id, id]);
await tx(async (c) => {
const msg = await one('SELECT * FROM inbox_messages WHERE id = ? FOR UPDATE', [id], c); if (!msg) throw notFound();
if (msg.status !== 'unmatched') throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED');
await run('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), t.id, t.created_by, 'customer', msg.body_text || '(kein Text)'], c);
await run("UPDATE tickets SET status = 'pending_staff', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [t.id], c);
await run("UPDATE inbox_messages SET status = 'matched', ticket_id = ? WHERE id = ?", [t.id, id], c);
});
await audit({ actorType: 'user', actorId: a.user.id, orgId: t.org_id, action: 'inbox.link', resourceType: 'inbox_message', resourceId: id, correlationId: req.correlationId, ip: clientIp(req), after: { ticketId: t.id } });
await notify('ticket.message', { number: t.number }, `mail-in-link:${id}`, req.correlationId);
return { ok: true };
});
app.post('/admin/inbox/:id/ignore', async (req) => {
const a = requirePermission(req, 'tickets.write'); const { id } = z.object({ id: z.string().uuid() }).parse(req.params);
const msg = await one('SELECT status FROM inbox_messages WHERE id = ?', [id]); if (!msg) throw notFound();
if (msg.status !== 'unmatched') throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED');
await run("UPDATE inbox_messages SET status = 'ignored' WHERE id = ?", [id]);
const r = await run("UPDATE inbox_messages SET status = 'ignored' WHERE id = ? AND status = 'unmatched'", [id]);
if (r.affectedRows === 0) { if (!(await one('SELECT 1 AS x FROM inbox_messages WHERE id = ?', [id]))) throw notFound(); throw conflict('Diese Nachricht wurde bereits bearbeitet.', 'ALREADY_HANDLED'); }
await audit({ actorType: 'user', actorId: a.user.id, action: 'inbox.ignore', resourceType: 'inbox_message', resourceId: id, correlationId: req.correlationId, ip: clientIp(req) });
return { ok: true };
});

View file

@ -33,7 +33,8 @@ function run(cmd: string, args: string[], o: { env?: Record<string, string>; std
let out = ''; let err = '';
if (o.stdout) p.stdout!.pipe(createWriteStream(o.stdout, { mode: 0o600 })); else p.stdout!.on('data', (d) => (out += d));
p.stderr!.on('data', (d) => { err += d; if (err.length > 4000) err = err.slice(-4000); });
if (o.stdin) createReadStream(o.stdin).pipe(p.stdin!); else if (o.stdinText !== undefined) { p.stdin!.on('error', () => undefined); p.stdin!.end(o.stdinText); }
// EPIPE abfangen, wenn das Programm (z.B. mysql) früh abbricht – der eigentliche Fehler kommt über Exit-Code und stderr
if (o.stdin) { p.stdin!.on('error', () => undefined); createReadStream(o.stdin).pipe(p.stdin!); } else if (o.stdinText !== undefined) { p.stdin!.on('error', () => undefined); p.stdin!.end(o.stdinText); }
p.on('error', (e) => reject(new Error(`${basename(cmd)} konnte nicht gestartet werden: ${e.message}`)));
p.on('close', (code) => (code === 0 ? resolve(out) : reject(new Error(`${basename(cmd)} Fehler (Exit ${code}): ${err.trim().split('\n').slice(-3).join(' | ')}`))));
});
@ -205,7 +206,11 @@ export async function runRestoreTest(c: BackupConfig, file?: string): Promise<No
try {
await admin.query(`DROP DATABASE IF EXISTS \`${scratch}\``); await admin.query(`CREATE DATABASE \`${scratch}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`);
} finally { await admin.end(); }
await run('mysql', [...dbArgs(), scratch], { env: dbEnv(), stdin: join(work, 'db.sql') });
// DEFINER der Trigger/Routinen ist umgebungsabhängig (z.B. phpMyAdmin-Importnutzer) und braucht SET USER –
// für den Test entfernen, dann gilt der verbindende Nutzer als DEFINER
const dump = (await readFile(join(work, 'db.sql'), 'utf8')).replace(/\/\*!50017 DEFINER=`[^`]*`@`[^`]*`\*\/ ?/g, '').replace(/ DEFINER=`[^`]*`@`[^`]*`/g, '');
await writeFile(join(work, 'restore.sql'), dump, { mode: 0o600 });
await run('mysql', [...dbArgs(), scratch], { env: dbEnv(), stdin: join(work, 'restore.sql') });
const conn = await mysql.createConnection({ host: config.db.host, port: config.db.port, user: config.db.user, password: config.db.password, database: scratch, timezone: 'Z' }); // UTC wie im Betrieb, sonst stimmt die Hash-Kette der Zeitstempel nicht
try {
const q = async (sql: string) => (await conn.query(sql))[0] as any[];

View file

@ -0,0 +1,27 @@
import { query } from '../core/db.js';
import { sendMail } from '@kc/platform/mail';
import { alertText, applyConditions, heartbeatAgeMs, type Condition } from '@kc/platform/monitor';
/** Ab dieser Herzschlag-Lücke gilt der Worker als ausgefallen (er schreibt jede Minute). */
const STALE_MS = 3 * 60_000;
/** Zustand „Worker arbeitet nicht“ aus dem Herzschlag. Noch nie geschrieben (frische Installation/alter Worker): kein Alarm. */
export async function workerDownCondition(): Promise<Condition> {
const age = await heartbeatAgeMs('worker');
const down = age !== null && age > STALE_MS;
return { key: 'worker.down', active: down, detail: down ? `letzter Herzschlag vor ${Math.round(age! / 60_000)} Minuten` : null, graceMs: 2 * 60_000 };
}
/**
* Den Ausfall des Workers kann der Worker nicht selbst melden – und Discord läuft im Worker. Die API prüft deshalb
* minütlich den Herzschlag und schreibt bei Ausfall/Entwarnung direkt per SMTP an alle aktiven Superadmins (#20/#38).
*/
export function startWorkerWatchdog(): void {
const notify = async (key: string, kind: 'alarm' | 'recovery', detail: string | null) => {
const text = alertText(key, kind, detail);
const admins = await query("SELECT email FROM users WHERE kind = 'staff' AND staff_role = 'superadmin' AND status = 'active'");
for (const a of admins) await sendMail(a.email, 'system_alert', `Kundencenter: ${text}`, `${text}\n\nPrüfen: systemctl status kc-worker; journalctl -u kc-worker -n 100`);
};
const tick = () => workerDownCondition().then((c) => applyConditions([c], notify)).catch(() => undefined);
setInterval(tick, 60_000).unref();
}

View file

@ -9,6 +9,7 @@ import { registerPermissions } from './core/policy.js';
import { AppError } from './core/errors.js';
import { InvalidTransition } from '@kc/platform/statemachine';
import { modules } from './modules/index.js';
import { startWorkerWatchdog } from './ops/watchdog.js';
export async function buildApp() {
const app = Fastify({
@ -40,4 +41,5 @@ export async function buildApp() {
if (import.meta.url === `file://${process.argv[1]}`) {
const app = await buildApp();
await app.listen({ port: config.port, host: '127.0.0.1' });
startWorkerWatchdog();
}

View file

@ -0,0 +1,75 @@
import { beforeAll, describe, expect, it } from 'vitest';
import type { FastifyInstance } from 'fastify';
import { randomUUID } from 'node:crypto';
import { buildApp } from '../src/server.js';
import { one, run } from '../src/core/db.js';
import { call, code, login, makeUser } from './helpers.js';
let app: FastifyInstance;
async function staff(email: string, role: string) {
await makeUser({ email, kind: 'staff', staffRole: role }); const { client } = await login(app, email);
const s = (await call(app, client, 'POST', '/auth/mfa/setup')).json(); await call(app, client, 'POST', '/auth/mfa/confirm', { code: code(s.secret) }); return client;
}
const inv = async (o: { issue: string | null; status: string; due?: string; lines: [number, number, string | null][]; cancels?: string }) => {
const id = randomUUID(); let net = 0, tax = 0;
for (const [n] of o.lines) net += n; for (const [n, bp] of o.lines) tax += Math.round((n * bp) / 10000);
await run('INSERT INTO invoices (id, number, org_id, status, issue_date, due_date, total_net_cents, total_tax_cents, total_gross_cents, cancels_invoice_id) VALUES (?,?,?,?,?,?,?,?,?,?)',
[id, o.status === 'draft' ? null : `RE-A${id.slice(0, 6)}`, ORG, o.status, o.issue, o.due ?? o.issue, net, tax, net + tax, o.cancels ?? null]);
let k = 0; for (const [n, bp, contract] of o.lines) { const t = Math.round((n * bp) / 10000);
await run('INSERT INTO invoice_items (id, invoice_id, contract_id, description, quantity, unit_price_net_cents, tax_bp, net_cents, tax_cents, gross_cents, sort_order) VALUES (?,?,?,?,1,?,?,?,?,?,?)', [randomUUID(), id, contract, 'x', n, bp, n, t, n + t, k++]); }
return id;
};
let ORG = ''; let MGMT: any; const STAFF: Record<string, any> = {};
beforeAll(async () => {
app = await buildApp(); await app.ready();
ORG = randomUUID(); await run("INSERT INTO organizations (id, customer_number, name, customer_type) VALUES (?, 'K-AN1', 'Auswertung AG', 'business')", [ORG]);
const tax = (await one('SELECT id FROM tax_rates WHERE rate_bp = 1900 LIMIT 1'))!.id; // vorhandene Stammdaten nutzen, nichts hinzufügen
const prod = randomUUID(), ver = randomUUID(), ord = randomUUID(), item = randomUUID(), con = randomUUID();
await run("INSERT INTO products (id, sku, category) VALUES (?, 'AN-HOST', 'hosting')", [prod]);
await run("INSERT INTO product_versions (id, product_id, version, name, tax_rate_id, tax_bp, billing_interval) VALUES (?,?,1,'Host',?,1900,'monthly')", [ver, prod, tax]);
await run("INSERT INTO orders (id, number, org_id, status, placed_via) VALUES (?, 'B-AN1', ?, 'completed', 'staff')", [ord, ORG]);
await run("INSERT INTO order_items (id, order_id, product_version_id, snapshot_json) VALUES (?,?,?,'{}')", [item, ord, ver]);
await run("INSERT INTO contracts (id, number, org_id, order_item_id, product_version_id, status, price_snapshot_json) VALUES (?, 'V-AN1', ?, ?, ?, 'active', '{}')", [con, ORG, item, ver]);
await inv({ issue: '2026-01-31', status: 'paid', lines: [[1000, 1900, con]] }); // Grenze: nur im Januar
await inv({ issue: '2026-02-01', status: 'open', due: '2026-02-15', lines: [[500, 700, null]] }); // offen + überfällig, 7 %, ohne Vertrag
const c = await inv({ issue: '2026-02-10', status: 'cancelled', lines: [[2000, 1900, con]] }); // storniert ...
await inv({ issue: '2026-02-12', status: 'open', lines: [[-2000, 1900, con]], cancels: c }); // ... durch Stornorechnung
await inv({ issue: null, status: 'draft', lines: [[99999, 1900, con]] }); // Entwurf zählt nie
});
describe('Management-Auswertung (#133)', () => {
it('Kennzahlen an festen Daten: Storno getrennt, Steuersätze, Kategorien, Zeitraumgrenze, Entwürfe ausgeschlossen', async () => {
const m = MGMT = await staff('an-mgmt@example.com', 'superadmin'); // Rolle wird unten auf management gesetzt
await run("UPDATE users SET staff_role = 'management' WHERE email = 'an-mgmt@example.com'");
const feb = (await call(app, m, 'GET', '/analytics/summary?from=2026-02-01&to=2026-02-28')).json();
expect(feb.invoices.issued).toEqual({ count: 2, netCents: 2500, taxCents: 415, grossCents: 2915 });
expect(feb.invoices.credits).toEqual({ count: 1, netCents: -2000, taxCents: -380, grossCents: -2380 });
expect(feb.invoices.netAfterCreditsCents).toBe(500); expect(feb.invoices.grossAfterCreditsCents).toBe(535);
expect(feb.invoices.markedPaid.grossCents).toBe(0); expect(feb.invoices.open.grossCents).toBe(535); expect(feb.invoices.overdueNow.grossCents).toBe(535);
expect(feb.byTaxRate).toEqual([{ taxBp: 1900, netCents: 0, taxCents: 0, grossCents: 0 }, { taxBp: 700, netCents: 500, taxCents: 35, grossCents: 535 }]);
expect(Object.fromEntries(feb.byCategory.map((c: any) => [c.category, c.netCents]))).toEqual({ hosting: 0, ohne_vertrag: 500 });
expect(feb.byMonth).toEqual([{ month: '2026-02', issuedNetCents: 2500, creditNetCents: -2000, netAfterCreditsCents: 500 }]);
const jan = (await call(app, m, 'GET', '/analytics/summary?from=2026-01-31&to=2026-01-31')).json();
expect(jan.invoices.issued.netCents).toBe(1000); expect(jan.invoices.markedPaid.grossCents).toBe(1190); expect(jan.invoices.credits.count).toBe(0);
expect(feb.currency).toBe('EUR'); expect(feb.definitions.join(' ')).toMatch(/kein gebuchter Zahlungseingang/);
expect((await call(app, m, 'GET', '/analytics/summary?from=2026-03-01&to=2026-02-01')).statusCode).toBe(400);
});
it('Rechte: nur Management; Management hat sonst nichts; keine Schreibwege; Rolle vergibt nur Superadmin', async () => {
const m = MGMT;
for (const role of ['support', 'accounting', 'admin', 'superadmin']) {
const c = STAFF[role] = await staff(`an-${role}@example.com`, role);
expect((await call(app, c, 'GET', '/analytics/summary?from=2026-01-01&to=2026-12-31')).statusCode).toBe(403);
}
await makeUser({ email: 'an-kunde@example.com' }); const k = (await login(app, 'an-kunde@example.com')).client;
expect((await call(app, k, 'GET', '/analytics/summary?from=2026-01-01&to=2026-12-31')).statusCode).toBe(403);
for (const url of ['/admin/customers', '/admin/users', '/admin/system', '/admin/drift', `/orgs/${ORG}`]) expect([403, 404]).toContain((await call(app, m, 'GET', url)).statusCode);
const list = await call(app, m, 'GET', '/invoices'); // Liste ist auch für Kunden – für Management ohne Mitgliedschaft leer
expect(list.statusCode === 403 || (Array.isArray(list.json()) ? list.json() : list.json().items ?? []).length === 0).toBe(true);
expect((await call(app, m, 'POST', '/invoices', { orgId: ORG })).statusCode).toBe(403);
expect((await call(app, m, 'POST', '/analytics/summary', {})).statusCode).toBe(404);
const admin = STAFF.admin; const sa = STAFF.superadmin;
expect((await call(app, admin, 'POST', '/admin/users', { email: 'neu-mgmt@example.com', name: 'M', staffRole: 'management' })).statusCode).toBe(403);
expect((await call(app, sa, 'POST', '/admin/users', { email: 'neu-mgmt@example.com', name: 'M', staffRole: 'management' })).statusCode).toBe(200);
});
});

View file

@ -0,0 +1,68 @@
import { describe, expect, it } from 'vitest';
import { randomUUID } from 'node:crypto';
import { one, query, run } from '../src/core/db.js';
import { duePeriods, releaseCancelledPeriods, runBilling } from '@kc/platform/billing';
let seq = 0;
async function contract(o: { interval: 'monthly' | 'yearly'; startedAt: string; net?: number; cancelEffective?: string }) {
seq++;
const org = randomUUID(); await run("INSERT INTO organizations (id, customer_number, name, customer_type) VALUES (?,?,?, 'business')", [org, `K-BIL${seq}`, `Abrechnung ${seq}`]);
const tax = (await one('SELECT id FROM tax_rates LIMIT 1'))!.id;
const prod = randomUUID(); const ver = randomUUID();
await run("INSERT INTO products (id, sku, category) VALUES (?,?, 'hosting')", [prod, `BIL-${seq}-${prod.slice(0, 6)}`]);
await run('INSERT INTO product_versions (id, product_id, version, name, tax_rate_id, tax_bp, billing_interval) VALUES (?,?,1,?,?,1900,?)', [ver, prod, `Paket ${seq}`, tax, o.interval]);
const ord = randomUUID(); const item = randomUUID(); const id = randomUUID();
await run("INSERT INTO orders (id, number, org_id, status, placed_via) VALUES (?,?,?, 'completed', 'staff')", [ord, `B-BIL${seq}`, org]);
const snap = { name: `Paket ${seq}`, interval: o.interval, taxBp: 1900, quantity: 1, discountBp: 0, recurring: { net: o.net ?? 1000, tax: 190, gross: 1190 }, setup: { net: 0, tax: 0, gross: 0 } };
await run('INSERT INTO order_items (id, order_id, product_version_id, snapshot_json) VALUES (?,?,?,?)', [item, ord, ver, JSON.stringify(snap)]);
await run("INSERT INTO contracts (id, number, org_id, order_item_id, product_version_id, status, started_at, renewal, renewal_term_months, cancel_effective_at, price_snapshot_json) VALUES (?,?,?,?,?, 'active', ?, 'auto', 12, ?, ?)",
[id, `V-BIL${seq}`, org, item, ver, new Date(o.startedAt), o.cancelEffective ? new Date(o.cancelEffective) : null, JSON.stringify(snap)]);
return { id, org };
}
const periodsOf = (cid: string) => query('SELECT period_start FROM invoice_billing_periods WHERE contract_id = ? ORDER BY period_start', [cid]).then((r) => r.map((x) => new Date(x.period_start).toISOString().slice(0, 10)));
describe('Abrechnungslauf (#50)', () => {
const now = new Date('2026-10-06T12:00:00Z');
it('monatlich: alle fälligen Perioden seit Beginn, im Voraus; zweiter Lauf erzeugt nichts', async () => {
const c = await contract({ interval: 'monthly', startedAt: '2026-08-15T00:00:00Z' });
const r = await runBilling(null, now);
expect(await periodsOf(c.id)).toEqual(['2026-08-15', '2026-09-15']); // 15.10. noch nicht fällig
const d = r.drafts.find((x) => x.orgId === c.org)!; expect(d.items).toBe(2);
const inv = await one('SELECT status, number, total_gross_cents FROM invoices WHERE id = ?', [d.invoiceId]);
expect(inv!.status).toBe('draft'); expect(inv!.number).toBeNull(); expect(Number(inv!.total_gross_cents)).toBe(2380);
expect((await runBilling(null, now)).drafts.find((x) => x.orgId === c.org)).toBeUndefined();
});
it('zwei parallele Läufe ergeben genau eine Rechnung je Periode', async () => {
const c = await contract({ interval: 'yearly', startedAt: '2026-01-10T00:00:00Z' });
const [a, b] = await Promise.all([runBilling(null, now), runBilling(null, now)]);
expect(await periodsOf(c.id)).toEqual(['2026-01-10']);
const drafts = [...a.drafts, ...b.drafts].filter((x) => x.orgId === c.org);
expect(drafts).toHaveLength(1);
expect(Number((await one("SELECT COUNT(*) AS n FROM invoices WHERE org_id = ?", [c.org]))!.n)).toBe(1); // kein leerer Entwurf übrig
});
it('gelöschter Entwurf gibt die Periode frei; Storno hält sie belegt bis zur ausdrücklichen Freigabe', async () => {
const c = await contract({ interval: 'yearly', startedAt: '2026-03-01T00:00:00Z' });
const d1 = (await runBilling(null, now)).drafts.find((x) => x.orgId === c.org)!;
await run('DELETE FROM invoice_items WHERE invoice_id = ?', [d1.invoiceId]); await run('DELETE FROM invoices WHERE id = ?', [d1.invoiceId]);
expect(await periodsOf(c.id)).toEqual([]);
const d2 = (await runBilling(null, now)).drafts.find((x) => x.orgId === c.org)!;
await run("UPDATE invoices SET status = 'cancelled' WHERE id = ?", [d2.invoiceId]); // vereinfacht: ausgestellt + storniert
expect((await runBilling(null, now)).drafts.find((x) => x.orgId === c.org)).toBeUndefined(); // keine stille Neuabrechnung
expect(await releaseCancelledPeriods(d2.invoiceId)).toBe(1);
expect((await runBilling(null, now)).drafts.find((x) => x.orgId === c.org)?.items).toBe(1);
expect(await releaseCancelledPeriods((await runBilling(null, now)).drafts[0]?.invoiceId ?? d2.invoiceId)).toBe(0);
});
it('keine Abrechnung über das wirksame Kündigungsdatum hinaus', async () => {
const c = await contract({ interval: 'monthly', startedAt: '2026-07-01T00:00:00Z', cancelEffective: '2026-09-01T00:00:00Z' });
await runBilling(null, now);
expect(await periodsOf(c.id)).toEqual(['2026-07-01', '2026-08-01']);
});
it('von Hand abgerechnete Verträge: keine Doppelrechnung für die bereits berechnete Periode', async () => {
const c = await contract({ interval: 'monthly', startedAt: '2026-08-01T00:00:00Z' });
const inv = randomUUID();
await run("INSERT INTO invoices (id, number, org_id, status, issue_date) VALUES (?, ?, ?, 'open', '2026-09-03')", [inv, `RE-HAND-${seq}`, c.org]);
await run("INSERT INTO invoice_items (id, invoice_id, contract_id, description, quantity, unit_price_net_cents, tax_bp, net_cents, tax_cents, gross_cents, sort_order) VALUES (?,?,?,'Hand',1,1000,1900,1000,190,1190,0)", [randomUUID(), inv, c.id]);
const due = (await duePeriods(now)).filter((p) => p.contractId === c.id).map((p) => p.start);
expect(due).toEqual(['2026-10-01']); // August/September gelten mit der Handrechnung vom 03.09. als berechnet
});
});

View file

@ -0,0 +1,42 @@
import { describe, expect, it } from 'vitest';
import { randomUUID } from 'node:crypto';
import { one, run } from '../src/core/db.js';
import { expectedState, findDrift, matches } from '@kc/platform/drift';
describe('Soll-Ist-Abgleich Vertrag ↔ Anbieter (#21)', () => {
it('Sollzustand je Vertragsstatus, Vergleichsregel', () => {
expect(expectedState('active')).toBe('active'); expect(expectedState('suspended')).toBe('suspended');
expect(expectedState('cancelled')).toBe('inactive'); expect(expectedState('pending')).toBeNull(); expect(expectedState('failed')).toBeNull();
expect(matches('inactive', 'expired')).toBe(true); expect(matches('inactive', 'active')).toBe(false); expect(matches('active', 'suspended')).toBe(false);
});
it('erkennt Abweichungen, kennzeichnet unsichere Beobachtungen und schreibt nichts zurück', async () => {
const org = randomUUID(); await run("INSERT INTO organizations (id, customer_number, name, customer_type) VALUES (?, 'K-DRIFT', 'Drift GmbH', 'business')", [org]);
const tax = (await one('SELECT id FROM tax_rates WHERE rate_bp = 1900 LIMIT 1'))!.id; // vorhandene Stammdaten nutzen, nichts hinzufügen
const ok = randomUUID(); const down = randomUUID();
await run("INSERT INTO connector_instances (id, connector_key, name, config_json, health) VALUES (?, 'mock', 'Drift ok', '{}', 'ok'), (?, 'mock', 'Drift gestört', '{}', 'down')", [ok, down]);
const mk = async (status: string, state: string, inst: string, syncedMinAgo = 0) => {
const prod = randomUUID(), ver = randomUUID(), ord = randomUUID(), item = randomUUID(), res = randomUUID(), con = randomUUID();
await run("INSERT INTO products (id, sku, category) VALUES (?, ?, 'hosting')", [prod, `DRIFT-${prod.slice(0, 8)}`]);
await run("INSERT INTO product_versions (id, product_id, version, name, tax_rate_id, tax_bp, billing_interval) VALUES (?,?,1,'P',?,1900,'monthly')", [ver, prod, tax]);
await run("INSERT INTO orders (id, number, org_id, status, placed_via) VALUES (?, ?, ?, 'completed', 'staff')", [ord, `B-D${ord.slice(0, 6)}`, org]);
await run("INSERT INTO order_items (id, order_id, product_version_id, snapshot_json) VALUES (?,?,?,'{}')", [item, ord, ver]);
await run('INSERT INTO resources (id, instance_id, external_ref, type, name, state, org_id, synced_at) VALUES (?,?,?,\'hosting\',?,?,?, DATE_SUB(UTC_TIMESTAMP(3), INTERVAL ? MINUTE))', [res, inst, res.slice(0, 8), `Res ${status}/${state}`, state, org, syncedMinAgo]);
await run("INSERT INTO contracts (id, number, org_id, order_item_id, product_version_id, status, resource_id, price_snapshot_json) VALUES (?,?,?,?,?,?,?,'{}')", [con, `V-D${con.slice(0, 6)}`, org, item, ver, status, res]);
return { con, res };
};
const a = await mk('active', 'suspended', ok); // Abweichung: im Panel gesperrt
const b = await mk('cancelled', 'active', ok); // Abweichung: beendet, aber aktiv
const c = await mk('active', 'active', ok); // passt
const d = await mk('suspended', 'active', down); // Anbieter gestört → ungewiss
const e = await mk('active', 'expired', ok, 120); // veraltet (Intervall 300 s × 3) → ungewiss
const f = await mk('pending', 'unknown', ok); // kein Soll → nicht verglichen
const drift = (await findDrift()).filter((x) => x.orgId === org);
const by = Object.fromEntries(drift.map((x) => [x.contractId, x.kind]));
expect(by[a.con]).toBe('mismatch'); expect(by[b.con]).toBe('mismatch');
expect(by[d.con]).toBe('uncertain'); expect(by[e.con]).toBe('uncertain');
expect(by[c.con]).toBeUndefined(); expect(by[f.con]).toBeUndefined();
expect(drift[0]!.kind).toBe('mismatch'); // sichere Abweichungen zuerst
expect((await one('SELECT state FROM resources WHERE id = ?', [a.res]))!.state).toBe('suspended'); // nichts zurückgeschrieben
});
});

View file

@ -5,6 +5,8 @@ import '../src/core/config.js';
/** Legt eine frische Testdatenbank an (niemals die produktive) und wendet alle Migrationen an. */
export default async function setup() {
// Schutz gegen versehentlichen Start auf einem Produktivhost: die Testdatenbank wird gelöscht und neu angelegt.
if (process.env.KC_TEST_DB_RESET !== '1') throw new Error('API-Tests löschen die Datenbank kundencenter_test. Nur in der isolierten Testumgebung starten (ops/test/run.sh) oder KC_TEST_DB_RESET=1 bewusst setzen.');
const base = { host: process.env.DB_HOST ?? '127.0.0.1', user: process.env.DB_USER!, password: process.env.DB_PASSWORD! };
const admin = await mysql.createConnection(base);
await admin.query('DROP DATABASE IF EXISTS kundencenter_test');

View file

@ -1,7 +1,7 @@
import { beforeAll, describe, expect, it } from 'vitest';
import type { FastifyInstance } from 'fastify';
import { buildApp } from '../src/server.js';
import { one, run } from '../src/core/db.js';
import { one, pool, query, run } from '../src/core/db.js';
import { runOnce } from '../../worker/src/jobs.js';
import { call, code, login, makeUser } from './helpers.js';
@ -247,6 +247,48 @@ describe('Rechnungen: eingefrorener Absender-/Empfänger-Stand, atomare Statuswe
const invAfter = (await call(app, acc, 'GET', `/invoices/${draft3.id}`)).json();
expect(invAfter.status).toBe('cancelled'); // nicht doppelt storniert, genau ein Storno-Verweis
});
it('Positionen speichern während parallel ausgestellt wird: das Speichern wartet und scheitert mit 409, Positionen/Summen bleiben unverändert (#95)', async () => {
const admin = await staff('race3-admin@example.com', 'superadmin'); const acc = await staff('race3-acc@example.com', 'accounting');
await call(app, admin, 'PUT', '/admin/company-settings', COMPANY);
const A = await customer(admin, 'Kunde Race3', 'race3-a@example.com');
const draft = (await call(app, acc, 'POST', '/invoices', { orgId: A.org })).json();
await call(app, acc, 'PUT', `/invoices/${draft.id}/items`, { items: [{ description: 'original', quantity: 1, unitPriceNetCents: 1000, taxBp: 1900 }] });
// Deterministisch: ein "Ausstellen" hält die Zeilensperre, das Speichern startet (Vorabprüfung sieht noch draft)
// und muss auf die Sperre warten; danach ist die Rechnung offen -> 409 statt veränderter Positionen.
const holder = await pool.getConnection();
try {
await holder.beginTransaction();
await holder.execute('SELECT status FROM invoices WHERE id = ? FOR UPDATE', [draft.id]);
const save = call(app, acc, 'PUT', `/invoices/${draft.id}/items`, { items: [{ description: 'manipuliert', quantity: 5, unitPriceNetCents: 99999, taxBp: 1900 }] });
await new Promise((r) => setTimeout(r, 300));
await holder.execute("UPDATE invoices SET status = 'open', number = 'RE-TEST-95', issue_date = CURDATE(), issued_at = UTC_TIMESTAMP(3) WHERE id = ?", [draft.id]);
await holder.commit();
expect((await save).statusCode).toBe(409);
} finally { holder.release(); }
const items = await query('SELECT description, gross_cents FROM invoice_items WHERE invoice_id = ?', [draft.id]);
expect(items.map((i) => i.description)).toEqual(['original']);
expect(Number((await one('SELECT total_gross_cents FROM invoices WHERE id = ?', [draft.id]))!.total_gross_cents)).toBe(1190);
});
it('Speichern und Ausstellen gleichzeitig: Summe der ausgestellten Rechnung passt immer zu ihren Positionen', async () => {
const admin = await staff('race4-admin@example.com', 'superadmin'); const acc = await staff('race4-acc@example.com', 'accounting');
await call(app, admin, 'PUT', '/admin/company-settings', COMPANY);
const A = await customer(admin, 'Kunde Race4', 'race4-a@example.com');
for (let i = 0; i < 5; i++) {
const draft = (await call(app, acc, 'POST', '/invoices', { orgId: A.org })).json();
await call(app, acc, 'PUT', `/invoices/${draft.id}/items`, { items: [{ description: 'a', quantity: 1, unitPriceNetCents: 1000, taxBp: 1900 }] });
const [save, issue] = await Promise.all([
call(app, acc, 'PUT', `/invoices/${draft.id}/items`, { items: [{ description: 'b', quantity: 2, unitPriceNetCents: 1000, taxBp: 1900 }] }),
call(app, acc, 'POST', `/invoices/${draft.id}/issue`),
]);
expect([200, 409]).toContain(save.statusCode); expect(issue.statusCode).toBe(200);
const inv = await one('SELECT total_gross_cents FROM invoices WHERE id = ?', [draft.id]);
const sum = await one('SELECT SUM(gross_cents) AS s FROM invoice_items WHERE invoice_id = ?', [draft.id]);
expect(Number(inv!.total_gross_cents)).toBe(Number(sum!.s));
}
});
});
describe('Rechnungspositionen: Rabatt je Position', () => {

View file

@ -0,0 +1,125 @@
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
import { generateKeyPairSync, createSign } from 'node:crypto';
import type { FastifyInstance } from 'fastify';
import { buildApp } from '../src/server.js';
import { one, run } from '../src/core/db.js';
import { checkLicenseNow, getEntitlement, setLicenseKey, setTestEdition } from '../src/core/license.js';
import { call, code, login, makeUser } from './helpers.js';
let app: FastifyInstance;
beforeAll(async () => { app = await buildApp(); await app.ready(); });
afterAll(() => { setTestEdition(null); vi.unstubAllGlobals(); });
async function staff(email: string, role: string) {
await makeUser({ email, kind: 'staff', staffRole: role }); const { client } = await login(app, email);
const s = (await call(app, client, 'POST', '/auth/mfa/setup')).json(); await call(app, client, 'POST', '/auth/mfa/confirm', { code: code(s.secret) }); return client;
}
describe('Kundengrenze und Benutzergrenze (#116)', () => {
it('paralleler letzter Platz wird genau einmal vergeben', async () => {
const admin = await staff('cap-admin@example.com', 'superadmin');
const n = Number((await one("SELECT COUNT(*) AS n FROM organizations WHERE status IN ('active','suspended')"))!.n);
setTestEdition({ mode: 'licensed', features: [], customerLimit: n + 1, staffLimit: null, reason: 'test' });
try {
const res = await Promise.all([1, 2, 3, 4].map((i) => call(app, admin, 'POST', '/admin/customers', { type: 'business', name: `Cap ${i}`, owner: { email: `cap${i}@example.com`, name: `Cap ${i}` } })));
expect(res.map((r) => r.statusCode).sort()).toEqual([200, 403, 403, 403]);
expect(Number((await one("SELECT COUNT(*) AS n FROM organizations WHERE status IN ('active','suspended')"))!.n)).toBe(n + 1);
} finally { setTestEdition(null); }
});
it('Personal: parallele Anlage und Reaktivierung halten die Grenze ein', async () => {
const admin = await staff('capst-admin@example.com', 'superadmin');
const n = Number((await one("SELECT COUNT(*) AS n FROM users WHERE kind = 'staff' AND status IN ('active','invited')"))!.n);
setTestEdition({ mode: 'licensed', features: [], customerLimit: null, staffLimit: n + 1, reason: 'test' });
try {
const res = await Promise.all([1, 2, 3].map((i) => call(app, admin, 'POST', '/admin/users', { email: `capst${i}@example.com`, name: `S ${i}`, staffRole: 'support' })));
expect(res.map((r) => r.statusCode).sort()).toEqual([200, 403, 403]);
// einen deaktivierten Mitarbeiter wieder aktivieren: kein Platz mehr frei
const off = await makeUser({ email: 'capst-off@example.com', kind: 'staff', staffRole: 'support' });
await run("UPDATE users SET status = 'disabled' WHERE id = ?", [off]);
const re = await call(app, admin, 'PATCH', `/admin/users/${off}`, { status: 'active' });
expect(re.statusCode).toBe(403); expect(re.json().error.code).toBe('STAFF_LIMIT_REACHED');
} finally { setTestEdition(null); }
});
});
describe('Lizenzantwort: Signatur ist Pflicht, Werte nur aus dem signierten Payload (#116)', () => {
const { privateKey, publicKey } = generateKeyPairSync('rsa', { modulusLength: 2048 });
const jwk = publicKey.export({ format: 'jwk' }) as { n: string; e: string };
const hex = (b64u: string) => Buffer.from(b64u, 'base64url').toString('hex');
const KID = 'test-kid-1'; const KEY = 'TEST-LIC-KEY-116';
const sign = (payload: Record<string, unknown>) => {
const b = Buffer.from(JSON.stringify({ ...payload, kid: KID, alg: 'RS256' })).toString('base64url');
const s = createSign('RSA-SHA256'); s.update(b, 'ascii'); s.end();
return `FLS1.${b}.${s.sign(privateKey).toString('base64url')}`;
};
let instanceId: string | null = null;
const body = (over: Record<string, unknown> = {}) => ({ typ: 'license.verify', licenseKey: KEY, instanceId, valid: true, plan: 'pro', modules: ['imap'], customerLimit: 50, userLimit: 5, expiresAt: null, entitlementVersion: 1, trial: false, addons: [], serverTime: new Date().toISOString(), ...over });
const respond = (outer: Record<string, unknown>) => vi.stubGlobal('fetch', vi.fn(async () => new Response(JSON.stringify(outer), { status: 200, headers: { 'content-type': 'application/json' } })));
beforeAll(async () => {
await run('DELETE FROM license_signing_keys');
await run("INSERT INTO license_signing_keys (kid, alg, n_hex, e_hex, status) VALUES (?, 'RS256', ?, ?, 'active')", [KID, hex(jwk.n), hex(jwk.e)]);
await run('UPDATE license_state SET server_time = NULL, checked_at = NULL WHERE id = 1');
await setLicenseKey(KEY);
instanceId = (await one('SELECT instance_id FROM license_state WHERE id = 1'))!.instance_id ?? null;
});
it('gültig signierte Antwort wird übernommen', async () => {
const p = body(); respond({ ...p, signature: sign(p) });
const r = await checkLicenseNow(); expect(r.customerLimit).toBe(50);
const e = await getEntitlement(); expect(e.valid).toBe(true); expect(e.modules).toEqual(['imap']);
});
it('fehlende Signatur wird abgewiesen, gespeicherter Stand bleibt', async () => {
respond({ ...body({ customerLimit: 100000 }) });
await expect(checkLicenseNow()).rejects.toThrow(/nicht signiert/);
expect((await getEntitlement()).customerLimit).toBe(50);
});
it('manipulierte äußere Felder werden ignoriert (nur Payload zählt)', async () => {
const p = body({ serverTime: new Date(Date.now() + 1000).toISOString() });
respond({ ...p, customerLimit: 100000, modules: ['discord', 'imap', 'datev'], valid: true, signature: sign(p) });
const r = await checkLicenseNow(); expect(r.customerLimit).toBe(50); expect(r.modules).toEqual(['imap']);
});
it('veränderter Payload (Signatur passt nicht) wird abgewiesen', async () => {
const p = body({ serverTime: new Date(Date.now() + 2000).toISOString() }); const tok = sign(p).split('.');
const forged = Buffer.from(JSON.stringify({ ...JSON.parse(Buffer.from(tok[1]!, 'base64url').toString()), customerLimit: 100000 })).toString('base64url');
respond({ ...p, signature: `FLS1.${forged}.${tok[2]}` });
await expect(checkLicenseNow()).rejects.toThrow(/Signaturprüfung/);
});
it('Wiedereinspielen einer älteren Antwort und fremde Installation werden abgewiesen', async () => {
const old = body({ serverTime: new Date(Date.now() - 60000).toISOString() }); respond({ ...old, signature: sign(old) });
await expect(checkLicenseNow()).rejects.toThrow(/älter als die zuletzt akzeptierte/);
const other = body({ instanceId: 'fremde-instanz', serverTime: new Date(Date.now() + 3000).toISOString() }); respond({ ...other, signature: sign(other) });
await expect(checkLicenseNow()).rejects.toThrow(/anderen Installation/);
const late = body({ serverTime: new Date(Date.now() + 3600000).toISOString() }); respond({ ...late, signature: sign(late) });
await expect(checkLicenseNow()).rejects.toThrow(/Serverzeit/);
});
});
describe('Kundengrenze bei Statuswechseln (#116, Codex-Repro)', () => {
it('closed → active und closed → suspended prüfen die Grenze; zählende Wechsel untereinander nicht', async () => {
const admin = await staff('capstat-admin@example.com', 'superadmin');
const mk = async (n: string) => (await call(app, admin, 'POST', '/admin/customers', { type: 'business', name: n, owner: { email: `${n.replace(/\s/g, '').toLowerCase()}@example.com`, name: n } })).json().id as string;
const x = await mk('Stat X'); const y = await mk('Stat Y');
await call(app, admin, 'PATCH', `/admin/customers/${x}`, { status: 'closed' });
const n = Number((await one("SELECT COUNT(*) AS n FROM organizations WHERE status IN ('active','suspended')"))!.n);
setTestEdition({ mode: 'licensed', features: [], customerLimit: n, staffLimit: null, reason: 'test' }); // voll belegt
try {
for (const to of ['suspended', 'active'] as const) {
const r = await call(app, admin, 'PATCH', `/admin/customers/${x}`, { status: to });
expect(r.statusCode).toBe(403); expect(r.json().error.code).toBe('CUSTOMER_LIMIT_REACHED');
}
expect((await one('SELECT status FROM organizations WHERE id = ?', [x]))!.status).toBe('closed');
expect(Number((await one("SELECT COUNT(*) AS n FROM organizations WHERE status IN ('active','suspended')"))!.n)).toBe(n);
// active ↔ suspended belegt keinen neuen Platz und bleibt erlaubt
expect((await call(app, admin, 'PATCH', `/admin/customers/${y}`, { status: 'suspended' })).statusCode).toBe(200);
expect((await call(app, admin, 'PATCH', `/admin/customers/${y}`, { status: 'active' })).statusCode).toBe(200);
// parallel: zwei closed-Kunden, ein freier Platz → genau einer wird reaktiviert
await call(app, admin, 'PATCH', `/admin/customers/${y}`, { status: 'closed' });
setTestEdition({ mode: 'licensed', features: [], customerLimit: n, staffLimit: null, reason: 'test' });
const res = await Promise.all([call(app, admin, 'PATCH', `/admin/customers/${x}`, { status: 'suspended' }), call(app, admin, 'PATCH', `/admin/customers/${y}`, { status: 'active' })]);
expect(res.map((r) => r.statusCode).sort()).toEqual([200, 403]);
expect(Number((await one("SELECT COUNT(*) AS n FROM organizations WHERE status IN ('active','suspended')"))!.n)).toBe(n);
} finally { setTestEdition(null); }
});
});

View file

@ -0,0 +1,50 @@
import { beforeAll, describe, expect, it } from 'vitest';
import { randomUUID } from 'node:crypto';
import { one, query, run } from '../src/core/db.js';
import { processMessage } from '../../worker/src/mailbox.js';
import { ticketReplyMessageId } from '@kc/platform/ticketmail';
import { makeUser } from './helpers.js';
const log = () => undefined;
const mail = (h: Record<string, string>, body = 'Hallo') => Buffer.from(Object.entries({ Date: new Date().toUTCString(), 'Message-ID': `<${randomUUID()}@ext.example>`, ...h }).map(([k, v]) => `${k}: ${v}`).join('\r\n') + '\r\n\r\n' + body);
let org: string; let ticketId: string; let ticketNumber: string;
beforeAll(async () => {
org = randomUUID(); await run("INSERT INTO organizations (id, customer_number, name, customer_type) VALUES (?, 'K-MAIL1', 'Mail AG', 'business')", [org]);
const u = await makeUser({ email: 'kunde@mail.example' }); await run("INSERT INTO memberships (org_id, user_id, role) VALUES (?,?,'owner')", [org, u]);
ticketId = randomUUID(); ticketNumber = 'T-77001';
await run("INSERT INTO tickets (id, number, org_id, subject, status, priority, created_by) VALUES (?,?,?,?, 'pending_customer', 'normal', ?)", [ticketId, ticketNumber, org, 'Problem', u]);
});
const msgs = () => query('SELECT body FROM ticket_messages WHERE ticket_id = ?', [ticketId]);
describe('IMAP-Posteingang (#107)', () => {
it('gefälschter Absender + Ticketnummer im Betreff hängt NICHTS an, landet mit Vorschlag im Posteingang', async () => {
await processMessage(1001, 9, mail({ From: 'kunde@mail.example', To: 'support@x', Subject: `Re: ${ticketNumber} Problem` }, 'gefälscht'), log);
expect(await msgs()).toHaveLength(0);
const r = await one('SELECT status, suggested_ticket_id, suggested_user_id FROM inbox_messages WHERE uid = 1001');
expect(r!.status).toBe('unmatched'); expect(r!.suggested_ticket_id).toBe(ticketId); expect(r!.suggested_user_id).toBeTruthy();
});
it('Antwort mit signiertem Bezug vom Kunden wird angehängt; Wiederholung derselben UID erzeugt keine Dublette', async () => {
const ref = ticketReplyMessageId(ticketId, 'support@flexible-domains.de');
const src = mail({ From: 'Kunde <kunde@mail.example>', To: 'support@x', Subject: 'Re: Ihr Ticket', 'In-Reply-To': ref, References: ref }, 'echte Antwort');
await processMessage(1002, 9, src, log);
await processMessage(1002, 9, src, log); // erneuter Lauf (z. B. nach Abbruch) – keine zweite Nachricht
expect((await msgs()).map((m) => m.body)).toEqual(['echte Antwort']);
expect((await one('SELECT status FROM tickets WHERE id = ?', [ticketId]))!.status).toBe('pending_staff');
});
it('gültiger Bezug, aber fremder Absender oder manipulierte Signatur → Posteingang', async () => {
const ref = ticketReplyMessageId(ticketId, 'support@flexible-domains.de');
await processMessage(1003, 9, mail({ From: 'angreifer@evil.example', Subject: 'Re', 'In-Reply-To': ref }), log);
const forged = ref.replace(/\.([A-Za-z0-9_-]{22})\./, '.AAAAAAAAAAAAAAAAAAAAAA.');
await processMessage(1004, 9, mail({ From: 'kunde@mail.example', Subject: 'Re', 'In-Reply-To': forged }), log);
expect((await msgs())).toHaveLength(1);
expect((await query("SELECT uid FROM inbox_messages WHERE uid IN (1003,1004) AND status = 'unmatched'"))).toHaveLength(2);
});
it('gesperrter Kunde: auch mit gültigem Bezug keine automatische Antwort', async () => {
await run("UPDATE organizations SET status = 'suspended' WHERE id = ?", [org]);
const ref = ticketReplyMessageId(ticketId, 'support@flexible-domains.de');
await processMessage(1005, 9, mail({ From: 'kunde@mail.example', Subject: 'Re', 'In-Reply-To': ref }), log);
expect((await msgs())).toHaveLength(1);
await run("UPDATE organizations SET status = 'active' WHERE id = ?", [org]);
});
});

View file

@ -0,0 +1,38 @@
import { describe, expect, it } from 'vitest';
import { mkdtempSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { migrate } from '../src/cli/migrate.js';
import { one, run } from '../src/core/db.js';
const dirWith = (files: Record<string, string>) => { const d = mkdtempSync(join(tmpdir(), 'kc-mig-')); for (const [n, c] of Object.entries(files)) writeFileSync(join(d, n), c); return d; };
describe('Migrationen (#100)', () => {
it('parallele Läufe: einer bekommt die Sperre, der andere bricht ab; danach ist die Sperre frei', async () => {
const dir = dirWith({ '900_slow.sql': 'CREATE TABLE IF NOT EXISTS t_mig_slow (id INT);\nSELECT SLEEP(1);\n' });
const res = await Promise.allSettled([migrate({ dir, lockTimeoutSec: 0 }), migrate({ dir, lockTimeoutSec: 0 })]);
expect(res.filter((r) => r.status === 'fulfilled')).toHaveLength(1);
const failed = res.find((r) => r.status === 'rejected') as PromiseRejectedResult;
expect(String(failed.reason.message)).toMatch(/Sperre/);
expect(Number((await one("SELECT IS_FREE_LOCK('kc_migrate') AS f"))!.f)).toBe(1);
expect(await one("SELECT name FROM schema_migrations WHERE name = '900_slow.sql'")).toBeTruthy();
});
it('Abbruch mitten in einer Migration: Fortschritt bleibt erhalten, weitere Läufe verweigern, --resume setzt fort', async () => {
const dir = dirWith({ '901_multi.sql': 'CREATE TABLE t_mig_a (id INT);\nINSERT INTO t_mig_dep (id) VALUES (1);\nCREATE TABLE t_mig_b (id INT);\n' });
await expect(migrate({ dir })).rejects.toThrow(/901_multi.sql, Anweisung 2 von 3/);
expect(Number((await one("SELECT IS_FREE_LOCK('kc_migrate') AS f"))!.f)).toBe(1); // Sperre auch nach Fehler frei
const d = await one("SELECT statements_done, error FROM schema_migrations_dirty WHERE name = '901_multi.sql'");
expect(d!.statements_done).toBe(1); expect(d!.error).toMatch(/t_mig_dep/);
await expect(migrate({ dir })).rejects.toThrow(/unvollständig: 1 von 3/); // ohne --resume keine Arbeit
await run('CREATE TABLE t_mig_dep (id INT)'); // Ursache beheben
expect(await migrate({ dir, resume: true })).toEqual(['901_multi.sql']); // CREATE TABLE t_mig_a wird NICHT wiederholt (würde sonst fehlschlagen)
expect(await one("SELECT name FROM schema_migrations_dirty WHERE name = '901_multi.sql'")).toBeUndefined();
expect(await one('SELECT COUNT(*) AS n FROM t_mig_b')).toBeTruthy();
});
it('veränderte angewendete Migration wird erkannt', async () => {
const dir = dirWith({ '900_slow.sql': 'SELECT 1;\n' });
await expect(migrate({ dir })).rejects.toThrow(/Prüfsumme weicht ab/);
});
});

View file

@ -0,0 +1,48 @@
import { describe, expect, it } from 'vitest';
import { run } from '../src/core/db.js';
import { applyConditions, heartbeat, workerConditions } from '@kc/platform/monitor';
import { workerDownCondition } from '../src/ops/watchdog.js';
describe('Betriebsalarme mit Entwarnung (#20/#38)', () => {
it('meldet erst nach der Karenzzeit, genau einmal, und entwarnt danach einmal', async () => {
const sent: string[] = []; const notify = async (k: string, kind: string) => { sent.push(`${k}:${kind}`); };
const t0 = new Date('2026-10-06T10:00:00Z'); const at = (min: number) => new Date(t0.getTime() + min * 60_000);
const c = (active: boolean) => [{ key: 'test.queue', active, detail: active ? 'Stau' : null, graceMs: 5 * 60_000 }];
await applyConditions(c(true), notify, at(0)); await applyConditions(c(true), notify, at(3));
expect(sent).toEqual([]); // kurzer Aussetzer: noch nichts
await applyConditions(c(true), notify, at(6)); await applyConditions(c(true), notify, at(7));
expect(sent).toEqual(['test.queue:alarm']); // dedupliziert
await applyConditions(c(false), notify, at(8)); await applyConditions(c(false), notify, at(9));
expect(sent).toEqual(['test.queue:alarm', 'test.queue:recovery']);
});
it('kurzer Vorfall unterhalb der Karenz: weder Alarm noch Entwarnung', async () => {
const sent: string[] = []; const notify = async (k: string, kind: string) => { sent.push(`${k}:${kind}`); };
const t = new Date('2026-10-06T11:00:00Z');
await applyConditions([{ key: 'test.blip', active: true, graceMs: 60_000 }], notify, t);
await applyConditions([{ key: 'test.blip', active: false }], notify, new Date(t.getTime() + 30_000));
expect(sent).toEqual([]);
});
it('unterscheidet Lizenzserver-Ausfall von Konfigurationsproblemen; ohne Schlüssel (Testmodus) kein Alarm', async () => {
await run("UPDATE license_state SET license_key_enc = 'x', last_error = 'Netzwerkfehler: timeout', last_error_kind = 'outage', valid = 1, checked_at = UTC_TIMESTAMP(3) WHERE id = 1");
let c = Object.fromEntries((await workerConditions()).map((x) => [x.key, x.active]));
expect(c['license.unreachable']).toBe(true); expect(c['license.problem']).toBe(false);
await run("UPDATE license_state SET last_error = 'Program-Key ungültig', last_error_kind = 'config' WHERE id = 1");
c = Object.fromEntries((await workerConditions()).map((x) => [x.key, x.active]));
expect(c['license.unreachable']).toBe(false); expect(c['license.problem']).toBe(true);
await run('UPDATE license_state SET license_key_enc = NULL WHERE id = 1');
c = Object.fromEntries((await workerConditions()).map((x) => [x.key, x.active]));
expect(c['license.unreachable']).toBe(false); expect(c['license.problem']).toBe(false);
await run('UPDATE license_state SET last_error = NULL, last_error_kind = NULL WHERE id = 1');
});
it('Warteschlangen-Stau und Aufträge zur Prüfung werden erkannt', async () => {
await run("INSERT INTO jobs (id, type, payload, status, run_at) VALUES (UUID(), 'x.test', '{}', 'scheduled', DATE_SUB(UTC_TIMESTAMP(3), INTERVAL 30 MINUTE)), (UUID(), 'x.test', '{}', 'needs_review', UTC_TIMESTAMP(3))");
const c = Object.fromEntries((await workerConditions()).map((x) => [x.key, x.active]));
expect(c['jobs.backlog']).toBe(true); expect(c['jobs.needs_review']).toBe(true);
await run("DELETE FROM jobs WHERE type = 'x.test'");
});
it('Worker-Herzschlag: frisch = in Ordnung, veraltet = ausgefallen', async () => {
await heartbeat('worker'); expect((await workerDownCondition()).active).toBe(false);
await run("UPDATE system_heartbeats SET at = DATE_SUB(UTC_TIMESTAMP(3), INTERVAL 10 MINUTE) WHERE name = 'worker'");
expect((await workerDownCondition()).active).toBe(true);
});
});

View file

@ -0,0 +1,59 @@
import { beforeAll, describe, expect, it } from 'vitest';
import type { FastifyInstance } from 'fastify';
import { buildApp } from '../src/server.js';
import { one, query, run } from '../src/core/db.js';
import { call, code, login, makeUser } from './helpers.js';
let app: FastifyInstance;
beforeAll(async () => { app = await buildApp(); await app.ready(); });
async function staff(email: string, role: string) {
await makeUser({ email, kind: 'staff', staffRole: role }); const { client } = await login(app, email);
const s = (await call(app, client, 'POST', '/auth/mfa/setup')).json(); await call(app, client, 'POST', '/auth/mfa/confirm', { code: code(s.secret) }); return client;
}
async function customer(admin: any, name: string, mail: string) {
const c = (await call(app, admin, 'POST', '/admin/customers', { type: 'business', name, owner: { email: mail, name } })).json();
await app.inject({ method: 'POST', url: '/v1/auth/invite/accept', payload: { token: new URL(c.inviteLink).searchParams.get('token'), password: 'passwort-kunde-123', repeat: 'passwort-kunde-123' } });
return { org: c.id as string, client: (await login(app, mail, 'passwort-kunde-123')).client };
}
describe('Bestellung: Hosting + Domain als getrennte Positionen (#80)', () => {
it('Preis/Laufzeit serverseitig aus der Domain-Preisliste, Freigabe durch Personal, Übernahme in die Domain-Aufstellung', async () => {
const admin = await staff('dom-admin@example.com', 'admin');
const A = await customer(admin, 'Domain Kunde', 'dom-kunde@example.com');
// Domain-Preisliste: .de mit Aufschlag, .xyz ohne Aufschlag (kein Verkaufspreis)
await run("INSERT INTO domain_tlds (tld, term_months, cost1_cents, cost2_cents, cost3_cents, cost4_cents, setup_cents, margin_type, margin_value) VALUES ('de', 12, 600, 550, 500, 450, 0, 'percent', 5000), ('xyz', 12, 1000, 1000, 1000, 1000, 0, NULL, NULL) ON DUPLICATE KEY UPDATE margin_type = VALUES(margin_type), margin_value = VALUES(margin_value)");
const tax = (await call(app, admin, 'GET', '/admin/tax-rates')).json(); const t19 = tax.find((t: any) => t.rateBp === 1900).id;
const prod = (await call(app, admin, 'POST', '/admin/products', { sku: 'WEB-S', category: 'hosting', orderableByCustomer: true, requiresApproval: false, customerActions: [], status: 'active',
version: { name: 'Webhosting S', taxRateId: t19, setupCents: 0, recurringCents: 500, billingInterval: 'monthly', termMonths: 1, renewal: 'auto', renewalTermMonths: 1, noticeDays: 30, provisioning: {} } })).json();
const order = (domains: object[]) => call(app, A.client, 'POST', '/orders', { orgId: A.org, items: [{ productId: prod.id, quantity: 1 }], domains, unitPrice: 1 });
expect((await order([{ name: 'kein domain' }])).json().error.code).toBe('DOMAIN_INVALID');
expect((await order([{ name: 'test.xyz' }])).json().error.code).toBe('DOMAIN_NO_PRICE'); // nie eine 0-Euro-Domain
expect((await order([{ name: 'a.de' }, { name: 'A.DE' }])).json().error.code).toBe('DOMAIN_DUPLICATE');
const r = await order([{ name: 'Meine-Firma.de' }]); expect(r.statusCode).toBe(200);
expect(r.json().status).toBe('pending_approval'); // Produkt ohne Freigabepflicht, aber Domains prüft immer das Personal
const o = (await call(app, A.client, 'GET', `/orders/${r.json().id}`)).json();
expect(o.domains).toHaveLength(1);
const d = o.domains[0]; expect(d.domain).toBe('meine-firma.de'); expect(d.termMonths).toBe(12); expect(d.recorded).toBe(false);
expect(d.sellGrossCents).toBeGreaterThan(600); expect(d.sellNetCents).toBeLessThan(d.sellGrossCents); // Aufschlag auf brutto-Einkauf, kein doppelter Steuerzuschlag
expect(await one("SELECT 1 AS x FROM domain_records WHERE domain = 'meine-firma.de'")).toBeUndefined(); // vor Freigabe nicht in Beschaffung
expect((await call(app, admin, 'POST', `/admin/orders/${r.json().id}/approve`)).statusCode).toBe(200);
const rec = (await one("SELECT org_id, procurement, sell_gross_cents, term_months, note FROM domain_records WHERE domain = 'meine-firma.de'"))!;
expect(rec.org_id).toBe(A.org); expect(rec.procurement).toBe('open'); expect(rec.sell_gross_cents).toBe(d.sellGrossCents); expect(rec.term_months).toBe(12); expect(rec.note).toMatch(/^Bestellung B-/);
expect((await call(app, A.client, 'GET', `/orders/${r.json().id}`)).json().domains[0].recorded).toBe(true);
expect((await order([{ name: 'meine-firma.de' }])).json().error.code).toBe('DOMAIN_EXISTS'); // bereits erfasst
});
it('abgelehnte Bestellung legt keine Domain an', async () => {
const admin = await staff('dom-admin2@example.com', 'admin');
const A = await customer(admin, 'Domain Kunde 2', 'dom-kunde2@example.com');
const prod = await one("SELECT id FROM products WHERE sku = 'WEB-S'");
const r = await call(app, A.client, 'POST', '/orders', { orgId: A.org, items: [{ productId: prod!.id, quantity: 1 }], domains: [{ name: 'abgelehnt.de' }] });
expect((await call(app, admin, 'POST', `/admin/orders/${r.json().id}/reject`, { reason: 'Test' })).statusCode).toBe(200);
expect(await one("SELECT 1 AS x FROM domain_records WHERE domain = 'abgelehnt.de'")).toBeUndefined();
expect((await query("SELECT domain FROM order_domains WHERE domain = 'abgelehnt.de'"))).toHaveLength(1); // Position bleibt nachvollziehbar
});
});

View file

@ -326,3 +326,22 @@ describe('Staffelpreise nach Laufzeit', () => {
expect(items[0].snapshot.terms).toEqual({ termMonths: 12, renewal: 'auto', renewalTermMonths: 12, noticeDays: 30 });
});
});
describe('Benutzer: Anmelde-E-Mail ändern', () => {
it('Personal ändert E-Mail/Name eines Kunden; alte Einladung ungültig, Duplikate und Mitarbeiter-E-Mails geschützt', async () => {
const admin = await staff('mail-adm@shop.test', 'admin'); const sa = await staff('mail-sa@shop.test', 'superadmin'); const sup = await staff('mail-sup@shop.test', 'support');
const c = (await call(app, admin, 'POST', '/admin/customers', { type: 'private', name: 'Alt Name', owner: { email: 'alt@shop.test', name: 'Alt Name' } })).json();
const oldToken = new URL(c.inviteLink).searchParams.get('token');
const uid = (await call(app, admin, 'GET', `/admin/customers/${c.id}`)).json().members[0].id;
expect((await call(app, sup, 'PATCH', `/admin/users/${uid}`, { email: 'neu@shop.test' })).statusCode).toBe(403);
expect((await call(app, admin, 'PATCH', `/admin/users/${uid}`, { email: 'mail-sa@shop.test' })).statusCode).toBe(409);
expect((await call(app, admin, 'PATCH', `/admin/users/${uid}`, { email: 'Neu@Shop.test', name: 'Neu Name' })).statusCode).toBe(200);
const m = (await call(app, admin, 'GET', `/admin/customers/${c.id}`)).json().members[0];
expect(m).toMatchObject({ email: 'neu@shop.test', name: 'Neu Name' });
expect((await app.inject({ method: 'POST', url: '/v1/auth/invite/accept', payload: { token: oldToken, password: 'passwort-kunde-123', repeat: 'passwort-kunde-123' } })).statusCode).toBe(400);
const saId = (await call(app, sa, 'GET', '/auth/me')).json().user.id;
expect((await call(app, admin, 'PATCH', `/admin/users/${saId}`, { email: 'x@shop.test' })).statusCode).toBe(403);
const log = await one("SELECT before_json FROM audit_events WHERE action = 'user.update' AND resource_id = ?", [uid]);
expect(JSON.stringify(log?.before_json)).toContain('alt@shop.test');
});
});

View file

@ -0,0 +1,69 @@
import { beforeAll, describe, expect, it } from 'vitest';
import type { FastifyInstance } from 'fastify';
import { buildApp } from '../src/server.js';
import { one, run } from '../src/core/db.js';
import { createToken } from '../src/core/accounts.js';
import { setTestEdition } from '../src/core/license.js';
import { call, code, login, makeUser } from './helpers.js';
let app: FastifyInstance; let admin: Awaited<ReturnType<typeof login>>['client'];
const post = (url: string, payload: unknown) => app.inject({ method: 'POST', url: `/v1${url}`, payload: payload as never, headers: { origin: 'http://localhost:4101' } });
const reg = (o: Record<string, unknown> = {}) => post('/auth/register', { type: 'private', name: 'Erika Muster', email: 'erika@reg.example', password: 'registrier-passwort-1', repeat: 'registrier-passwort-1', acceptPrivacy: true, ...o });
const userBy = (email: string) => one('SELECT id, status, email_verified_at FROM users WHERE email = ?', [email]);
const canLogin = async (email: string) => (await post('/auth/login', { email, password: 'registrier-passwort-1' })).statusCode === 200;
beforeAll(async () => {
app = await buildApp(); await app.ready();
await makeUser({ email: 'reg-admin@example.com', kind: 'staff', staffRole: 'superadmin' }); admin = (await login(app, 'reg-admin@example.com')).client;
const s = (await call(app, admin, 'POST', '/auth/mfa/setup')).json(); await call(app, admin, 'POST', '/auth/mfa/confirm', { code: code(s.secret) });
});
describe('Selbstregistrierung (#36)', () => {
it('standardmäßig aus: keine Registrierung möglich', async () => {
expect((await app.inject({ method: 'GET', url: '/v1/auth/registration' })).json().enabled).toBe(false);
expect((await reg()).statusCode).toBe(404);
});
it('Freischaltung durch Personal: Bestätigung allein erlaubt noch keine Anmeldung', async () => {
expect((await call(app, admin, 'PUT', '/admin/registration-settings', { enabled: true, approval: 'manual' })).statusCode).toBe(200);
expect((await reg()).statusCode).toBe(202);
const u = (await userBy('erika@reg.example'))!; expect(u.status).toBe('invited'); expect(await canLogin('erika@reg.example')).toBe(false);
expect((await one("SELECT o.source FROM organizations o JOIN memberships m ON m.org_id = o.id WHERE m.user_id = ?", [u.id]))!.source).toBe('registration');
const t = await createToken(undefined, u.id, 'verify_email');
expect((await post('/auth/verify-email', { token: t })).json().status).toBe('pending_approval');
expect((await post('/auth/verify-email', { token: t })).statusCode).toBe(400); // Einmal-Token
expect(await canLogin('erika@reg.example')).toBe(false);
const list = (await call(app, admin, 'GET', '/admin/registrations')).json(); expect(list.map((r: any) => r.email)).toContain('erika@reg.example');
expect((await call(app, admin, 'POST', `/admin/registrations/${u.id}/approve`)).statusCode).toBe(200);
expect(await canLogin('erika@reg.example')).toBe(true);
});
it('keine Auskunft über bestehende Konten: gleiche Antwort, kein zweites Konto', async () => {
const r = await reg(); expect(r.statusCode).toBe(202); expect(r.json()).toEqual({ status: 'check_mail' });
expect(Number((await one("SELECT COUNT(*) AS n FROM users WHERE email = 'erika@reg.example'"))!.n)).toBe(1);
});
it('automatische Freischaltung, Ablehnung, abgelaufener Link', async () => {
await call(app, admin, 'PUT', '/admin/registration-settings', { enabled: true, approval: 'auto' });
await reg({ type: 'business', name: 'Muster GmbH', contactName: 'Max Muster', email: 'max@reg.example', vatId: 'DE 123.456.789' });
const u = (await userBy('max@reg.example'))!;
const t = await createToken(undefined, u.id, 'verify_email');
expect((await post('/auth/verify-email', { token: t })).json().status).toBe('active'); expect(await canLogin('max@reg.example')).toBe(true);
await reg({ email: 'old@reg.example' }); const o = (await userBy('old@reg.example'))!;
const t2 = await createToken(undefined, o.id, 'verify_email'); await run("UPDATE user_tokens SET expires_at = DATE_SUB(UTC_TIMESTAMP(3), INTERVAL 1 MINUTE) WHERE user_id = ?", [o.id]);
expect((await post('/auth/verify-email', { token: t2 })).statusCode).toBe(400);
await call(app, admin, 'PUT', '/admin/registration-settings', { enabled: true, approval: 'manual' });
await reg({ email: 'nein@reg.example' }); const n = (await userBy('nein@reg.example'))!;
await post('/auth/verify-email', { token: await createToken(undefined, n.id, 'verify_email') });
expect((await call(app, admin, 'POST', `/admin/registrations/${n.id}/reject`)).statusCode).toBe(200);
expect((await userBy('nein@reg.example'))!.status).toBe('disabled');
});
it('Fachregeln und Kundengrenze gelten', async () => {
expect((await reg({ email: 'p@reg.example', vatId: 'DE123456789' })).statusCode).toBe(400); // Privatkunde ohne USt-IdNr.
expect((await reg({ email: 'b@reg.example', type: 'business', name: 'X AG', vatId: 'ungültig!' })).statusCode).toBe(400);
expect((await reg({ email: 'w@reg.example', repeat: 'anders-passwort-12' })).statusCode).toBe(400);
expect((await reg({ email: 'd@reg.example', acceptPrivacy: false })).statusCode).toBe(400);
const cnt = Number((await one("SELECT COUNT(*) AS n FROM organizations WHERE status IN ('active','suspended')"))!.n);
setTestEdition({ mode: 'licensed', features: [], customerLimit: cnt, staffLimit: null, reason: 'test' });
try { const r = await reg({ email: 'voll@reg.example' }); expect(r.statusCode).toBe(403); expect(r.json().error.code).toBe('REGISTRATION_UNAVAILABLE'); }
finally { setTestEdition(null); }
expect((await call(app, admin, 'PUT', '/admin/registration-settings', { enabled: false, approval: 'manual' })).statusCode).toBe(200);
});
});

View file

@ -0,0 +1,49 @@
import { beforeAll, describe, expect, it } from 'vitest';
import type { FastifyInstance } from 'fastify';
import { randomUUID } from 'node:crypto';
import { buildApp } from '../src/server.js';
import { one, query, run } from '../src/core/db.js';
import { recoverStale } from '../../worker/src/jobs.js';
import { call, code, login, makeUser } from './helpers.js';
let app: FastifyInstance;
beforeAll(async () => { app = await buildApp(); await app.ready(); });
async function staff(email: string, role: string) {
await makeUser({ email, kind: 'staff', staffRole: role }); const { client } = await login(app, email);
const s = (await call(app, client, 'POST', '/auth/mfa/setup')).json(); await call(app, client, 'POST', '/auth/mfa/confirm', { code: code(s.secret) }); return client;
}
describe('Impersonation „Als Kunde ansehen“ (T7)', () => {
it('nur admin/superadmin, Grund Pflicht, wirkt als Kunde genau dieser Organisation, auditiert', async () => {
const admin = await staff('imp-admin@example.com', 'admin'); const support = await staff('imp-support@example.com', 'support');
const A = (await call(app, admin, 'POST', '/admin/customers', { type: 'business', name: 'Imp A', owner: { email: 'imp-a@example.com', name: 'A' } })).json();
const B = (await call(app, admin, 'POST', '/admin/customers', { type: 'business', name: 'Imp B', owner: { email: 'imp-b@example.com', name: 'B' } })).json();
expect((await call(app, support, 'POST', `/admin/customers/${A.id}/impersonate`, { reason: 'Test' })).statusCode).toBe(403);
expect((await call(app, admin, 'POST', `/admin/customers/${A.id}/impersonate`, {})).statusCode).toBe(400);
expect((await call(app, admin, 'POST', `/admin/customers/${A.id}/impersonate`, { reason: 'Kunde bittet um Hilfe' })).statusCode).toBe(200);
const me = (await call(app, admin, 'GET', '/auth/me')).json();
expect(me.impersonating.orgId).toBe(A.id);
expect((await call(app, admin, 'GET', `/orgs/${A.id}`)).statusCode).toBe(200);
expect([403, 404]).toContain((await call(app, admin, 'GET', `/orgs/${B.id}`)).statusCode); // fremde Organisation
expect((await call(app, admin, 'GET', '/admin/customers')).statusCode).toBe(403); // keine Personalrechte während der Ansicht
expect((await call(app, admin, 'POST', '/auth/impersonate/stop')).statusCode).toBe(200);
expect((await call(app, admin, 'GET', '/admin/customers')).statusCode).toBe(200);
const actions = (await query("SELECT action FROM audit_events WHERE action LIKE 'customer.impersonate.%' AND org_id = ? ORDER BY id", [A.id])).map((r) => r.action);
expect(actions).toEqual(['customer.impersonate.start', 'customer.impersonate.end']);
});
});
describe('Job-Lease nach Absturz (T15)', () => {
it('normale Aufträge werden wieder eingeplant, destruktive gehen zur Prüfung; laufende mit frischem Herzschlag bleiben unberührt', async () => {
const ids = { normal: randomUUID(), destr: randomUUID(), fresh: randomUUID() };
await run("INSERT INTO jobs (id, type, payload, status, locked_at, lease_id, run_at) VALUES (?, 'x.lease', '{}', 'running', DATE_SUB(UTC_TIMESTAMP(3), INTERVAL 10 MINUTE), 'l1', UTC_TIMESTAMP(3))", [ids.normal]);
await run("INSERT INTO jobs (id, type, payload, status, locked_at, lease_id, run_at) VALUES (?, 'x.lease', '{\"destructive\":true}', 'running', DATE_SUB(UTC_TIMESTAMP(3), INTERVAL 10 MINUTE), 'l2', UTC_TIMESTAMP(3))", [ids.destr]);
await run("INSERT INTO jobs (id, type, payload, status, locked_at, lease_id, run_at) VALUES (?, 'x.lease', '{}', 'running', UTC_TIMESTAMP(3), 'l3', UTC_TIMESTAMP(3))", [ids.fresh]);
await recoverStale(() => undefined);
const st = async (id: string) => (await one('SELECT status, lease_id FROM jobs WHERE id = ?', [id]))!;
expect((await st(ids.normal)).status).toBe('retrying'); expect((await st(ids.normal)).lease_id).toBeNull();
expect((await st(ids.destr)).status).toBe('needs_review');
expect((await st(ids.fresh)).status).toBe('running');
await run("DELETE FROM jobs WHERE type = 'x.lease'");
});
});

View file

@ -0,0 +1,34 @@
import { beforeAll, describe, expect, it } from 'vitest';
import type { FastifyInstance } from 'fastify';
import { buildApp } from '../src/server.js';
import { call, code, login, makeUser } from './helpers.js';
let app: FastifyInstance;
beforeAll(async () => { app = await buildApp(); await app.ready(); });
const pub = async () => (await app.inject({ method: 'GET', url: '/v1/public/status' })).json();
async function staff(email: string, role: string) {
await makeUser({ email, kind: 'staff', staffRole: role }); const { client } = await login(app, email);
const s = (await call(app, client, 'POST', '/auth/mfa/setup')).json(); await call(app, client, 'POST', '/auth/mfa/confirm', { code: code(s.secret) }); return client;
}
describe('Öffentliche Statusseite (#23)', () => {
it('nur Veröffentlichtes ist öffentlich, ohne interne Felder; Gesamtzustand und Abschluss', async () => {
const sup = await staff('status-support@example.com', 'support'); const acc = await staff('status-buha@example.com', 'accounting');
await makeUser({ email: 'status-kunde@example.com' }); const cust = (await login(app, 'status-kunde@example.com')).client;
expect((await pub()).overall).toBe('ok');
expect((await call(app, cust, 'POST', '/admin/status-events', { kind: 'incident', title: 'X', body: 'xxx' })).statusCode).toBe(403);
expect((await call(app, acc, 'POST', '/admin/status-events', { kind: 'incident', title: 'X', body: 'xxx' })).statusCode).toBe(403);
const ev = (await call(app, sup, 'POST', '/admin/status-events', { kind: 'incident', title: 'E-Mail verzögert', component: 'E-Mail', impact: 'major', body: 'Wir untersuchen das.' })).json();
expect((await pub()).current).toHaveLength(0); // nicht veröffentlicht
await call(app, sup, 'POST', `/admin/status-events/${ev.id}/update`, { published: true, state: 'identified', body: 'Ursache gefunden.' });
let p = await pub(); expect(p.overall).toBe('major'); expect(p.current[0].title).toBe('E-Mail verzögert');
expect(p.current[0].updates.map((u: any) => u.state)).toEqual(['identified', 'investigating']);
const keys = Object.keys(p.current[0]); for (const k of ['published', 'created_by', 'createdBy']) expect(keys).not.toContain(k);
expect((await call(app, sup, 'POST', `/admin/status-events/${ev.id}/update`, { state: 'completed' })).statusCode).toBe(400); // passt nicht zu Störung
await call(app, sup, 'POST', `/admin/status-events/${ev.id}/update`, { state: 'resolved', body: 'Behoben.' });
p = await pub(); expect(p.overall).toBe('ok'); expect(p.recent[0].state).toBe('resolved'); expect(p.recent[0].endsAt).toBeTruthy();
// geplante Wartung in der Zukunft: angekündigt, beeinflusst den Gesamtzustand noch nicht
await call(app, sup, 'POST', '/admin/status-events', { kind: 'maintenance', title: 'Wartung Webserver', impact: 'minor', startsAt: new Date(Date.now() + 86400000).toISOString(), body: 'Kurze Unterbrechung möglich.', published: true });
p = await pub(); expect(p.overall).toBe('ok'); expect(p.current.map((e: any) => e.kind)).toContain('maintenance');
});
});

View file

@ -0,0 +1,96 @@
import { beforeAll, describe, expect, it } from 'vitest';
import { randomUUID } from 'node:crypto';
import { one, query, run } from '../src/core/db.js';
import { runOnce } from '../../worker/src/jobs.js';
import { handleThreadMessage } from '../../worker/src/discord.js';
import { makeUser } from './helpers.js';
const log = () => undefined;
const runJob = async (id: string) => { await run('UPDATE jobs SET run_at = UTC_TIMESTAMP(3) WHERE id = ?', [id]); return runOnce(log); };
describe('Worker: Job-Runner', () => {
it('Fehler wird mit Backoff wiederholt und landet nach max_attempts in needs_review', async () => {
const id = randomUUID();
await run("INSERT INTO jobs (id, type, payload, status, max_attempts, run_at) VALUES (?, 'x.unbekannt', '{}', 'scheduled', 2, UTC_TIMESTAMP(3))", [id]);
await runJob(id);
let j = (await one('SELECT status, attempts, run_at, last_error FROM jobs WHERE id = ?', [id]))!;
expect(j.status).toBe('retrying'); expect(j.attempts).toBe(1); expect(j.last_error).toMatch(/Kein Handler/);
expect(new Date(j.run_at).getTime()).toBeGreaterThan(Date.now() + 30_000); // Backoff
await runJob(id);
j = (await one('SELECT status, attempts, lease_id FROM jobs WHERE id = ?', [id]))!;
expect(j.status).toBe('needs_review'); expect(j.attempts).toBe(2); expect(j.lease_id).toBeNull();
});
});
describe('Worker: Discord-Nachrichten im Ticketkanal (#110)', () => {
let org: string; let ticket: string; let customer: string; let support: string; let accounting: string;
const channel = `chan-${randomUUID().slice(0, 8)}`;
const replies: string[] = [];
const msg = (authorId: string, content: string) => ({ id: randomUUID(), author: { id: authorId, bot: false }, inGuild: () => true, channel: { id: channel }, content, reply: async (t: string) => { replies.push(t); } }) as never;
const messages = () => query('SELECT author_kind, body FROM ticket_messages WHERE ticket_id = ? ORDER BY created_at', [ticket]);
beforeAll(async () => {
org = randomUUID(); await run("INSERT INTO organizations (id, customer_number, name, customer_type) VALUES (?, 'K-DISC1', 'Discord AG', 'business')", [org]);
customer = await makeUser({ email: 'disc-kunde@example.com' }); await run("INSERT INTO memberships (org_id, user_id, role) VALUES (?,?,'owner')", [org, customer]);
support = await makeUser({ email: 'disc-support@example.com', kind: 'staff', staffRole: 'support' });
accounting = await makeUser({ email: 'disc-buchhaltung@example.com', kind: 'staff', staffRole: 'accounting' });
for (const [u, d] of [[customer, 'd-kunde'], [support, 'd-support'], [accounting, 'd-buha']]) await run('UPDATE users SET discord_user_id = ? WHERE id = ?', [d, u]);
ticket = randomUUID();
await run("INSERT INTO tickets (id, number, org_id, subject, status, priority, created_by) VALUES (?, 'T-88001', ?, 'Discord', 'pending_customer', 'normal', ?)", [ticket, org, customer]);
await run('INSERT INTO ticket_discord_threads (ticket_id, thread_id) VALUES (?,?)', [ticket, channel]);
});
it('Kundenantwort wird übernommen und setzt „wartet auf Support“', async () => {
await handleThreadMessage(msg('d-kunde', 'Hallo vom Kunden'), log);
expect((await messages()).map((m) => m.body)).toEqual(['Hallo vom Kunden']);
expect((await one('SELECT status FROM tickets WHERE id = ?', [ticket]))!.status).toBe('pending_staff');
});
it('Support-Antwort wird übernommen, Mail mit signiertem Antwort-Bezug wird eingeplant', async () => {
await handleThreadMessage(msg('d-support', 'Antwort vom Support'), log);
expect((await messages()).at(-1)).toMatchObject({ author_kind: 'staff', body: 'Antwort vom Support' });
const job = await one("SELECT payload FROM jobs WHERE type = 'mail.template' ORDER BY created_at DESC LIMIT 1");
const p = typeof job!.payload === 'string' ? JSON.parse(job!.payload) : job!.payload;
expect(p.replyTicketId).toBe(ticket); expect(p.to).toBe('disc-kunde@example.com');
});
it('Buchhaltung (nur lesen) kann nicht antworten', async () => {
const before = (await messages()).length;
await handleThreadMessage(msg('d-buha', 'darf ich nicht'), log);
expect((await messages()).length).toBe(before); expect(replies.at(-1)).toMatch(/nur lesen/);
});
it('gesperrter Kunde und unbekanntes Discord-Konto werden nicht übernommen', async () => {
await run("UPDATE organizations SET status = 'suspended' WHERE id = ?", [org]);
const before = (await messages()).length;
await handleThreadMessage(msg('d-kunde', 'gesperrt'), log);
await handleThreadMessage(msg('fremd-123', 'wer bin ich'), log);
expect((await messages()).length).toBe(before); expect(replies.at(-1)).toMatch(/gesperrt/);
await run("UPDATE organizations SET status = 'active' WHERE id = ?", [org]);
});
it('geschlossenes Ticket nimmt keine Nachrichten an', async () => {
await run("UPDATE tickets SET status = 'closed' WHERE id = ?", [ticket]);
const before = (await messages()).length;
await handleThreadMessage(msg('d-kunde', 'noch was'), log);
expect((await messages()).length).toBe(before); expect(replies.at(-1)).toMatch(/geschlossen/);
});
});
describe('Kundenangaben beim Anbieter nachziehen (#64)', () => {
it('Namensänderung plant den Abgleich; Objekte ohne Fähigkeit werden übersprungen und gezählt, keine Daten in Logs', async () => {
const { buildApp } = await import('../src/server.js'); const { call, code, login } = await import('./helpers.js');
const app = await buildApp(); await app.ready();
await makeUser({ email: 'sync-admin@example.com', kind: 'staff', staffRole: 'superadmin' }); const { client } = await login(app, 'sync-admin@example.com');
const s = (await call(app, client, 'POST', '/auth/mfa/setup')).json(); await call(app, client, 'POST', '/auth/mfa/confirm', { code: code(s.secret) });
const org = (await call(app, client, 'POST', '/admin/customers', { type: 'business', name: 'Sync Alt', owner: { email: 'sync-owner@example.com', name: 'Owner' } })).json().id as string;
const inst = randomUUID(); await run("INSERT INTO connector_instances (id, connector_key, name, config_json, enabled) VALUES (?, 'mock', CONCAT('Mock ', ?), '{}', 1)", [inst, inst.slice(0, 8)]);
await run("INSERT INTO resources (id, instance_id, external_ref, type, name, state, org_id, synced_at) VALUES (UUID(), ?, 'm-1', 'license', 'Lizenz', 'active', ?, UTC_TIMESTAMP(3))", [inst, org]);
expect((await call(app, client, 'PATCH', `/admin/customers/${org}`, { name: 'Sync Neu' })).statusCode).toBe(200);
const job = (await one("SELECT id FROM jobs WHERE type = 'customer.provider_sync' AND JSON_VALUE(payload, '$.orgId') = ?", [org]))!;
for (let i = 0; i < 20 && (await one('SELECT status FROM jobs WHERE id = ?', [job.id]))!.status === 'scheduled'; i++) await runJob(job.id); // ältere Aufträge kommen zuerst
const j = (await one('SELECT status, last_error FROM jobs WHERE id = ?', [job.id]))!;
expect(j.status).toBe('succeeded'); expect(j.last_error).toMatch(/0 aktualisiert, 1 übersprungen/);
expect((await call(app, client, 'POST', `/admin/customers/${org}/provider-sync`, { mode: 'erase' })).statusCode).toBe(200);
expect(await one("SELECT 1 AS x FROM jobs WHERE type = 'customer.provider_sync' AND JSON_VALUE(payload, '$.mode') = 'erase' AND JSON_VALUE(payload, '$.orgId') = ?", [org])).toBeTruthy();
const audit = await query("SELECT after_json FROM audit_events WHERE action = 'customer.provider_sync.update' AND org_id = ?", [org]);
expect(JSON.stringify(audit)).not.toMatch(/Sync Neu|sync-owner/); // keine personenbezogenen Werte im Audit
await app.close();
});
});

20
apps/e2e/package.json Normal file
View file

@ -0,0 +1,20 @@
{
"name": "@kc/e2e",
"private": true,
"version": "0.0.1",
"type": "module",
"scripts": {
"build": "echo 'nichts zu bauen'",
"typecheck": "echo 'Playwright prüft die Tests selbst'",
"test": "echo 'Browser-Tests: ops/test/run-e2e.sh'",
"e2e": "node setup-db.ts && playwright test"
},
"devDependencies": {
"@axe-core/playwright": "4.13.0",
"@kc/platform": "workspace:*",
"@node-rs/argon2": "^2.2.1",
"@playwright/test": "1.63.0",
"mysql2": "^3.24.4",
"otpauth": "^9.5.2"
}
}

View file

@ -0,0 +1,24 @@
import { defineConfig, devices } from '@playwright/test';
/**
* Browser-Abnahme (#39/#15): echte API + Web gegen die Wegwerf-Datenbank kundencenter_e2e.
* Start nur über ops/test/run-e2e.sh (setzt Dummy-Schlüssel und KC_TEST_DB_RESET=1).
*/
const env = { ...process.env, DB_NAME: 'kundencenter_e2e', KC_NODE_ENV: 'test', KC_BASE_URL: 'http://127.0.0.1:4101', TICKET_ATTACHMENT_DIR: '/tmp/kc-e2e-attachments' } as Record<string, string>;
export default defineConfig({
testDir: 'tests',
fullyParallel: false,
workers: 1,
retries: 0,
timeout: 120_000, // Anmeldungen warten ggf. auf ein neues 30-s-TOTP-Fenster (Replay-Schutz)
reporter: [['list']],
use: { baseURL: 'http://127.0.0.1:4101', trace: 'retain-on-failure', locale: 'de-DE', timezoneId: 'Europe/Berlin' },
projects: [
{ name: 'desktop-hell', use: { ...devices['Desktop Chrome'], colorScheme: 'light' } },
{ name: 'mobil-dunkel', use: { ...devices['Desktop Chrome'], viewport: { width: 360, height: 780 }, isMobile: true, hasTouch: true, colorScheme: 'dark' } },
],
webServer: [
{ command: 'node ../api/dist/server.js', url: 'http://127.0.0.1:4100/v1/ready', env: { ...env, KC_API_PORT: '4100' }, reuseExistingServer: false, timeout: 60_000, stdout: 'ignore', stderr: 'pipe' },
{ command: 'pnpm --filter @kc/web start', url: 'http://127.0.0.1:4101/login', env: { ...env, KC_API_URL: 'http://127.0.0.1:4100' }, reuseExistingServer: false, timeout: 120_000 },
],
});

46
apps/e2e/setup-db.ts Normal file
View file

@ -0,0 +1,46 @@
import mysql from 'mysql2/promise';
import { readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
import { join } from 'node:path';
import { randomUUID } from 'node:crypto';
import { hash } from '@node-rs/argon2';
import * as OTPAuth from 'otpauth';
/** Frische Datenbank kundencenter_e2e mit allen Migrationen und einem Superadmin mit eingerichteter 2FA.
* Läuft VOR Playwright (dessen webServer starten vor einem globalSetup). */
async function setup() {
if (process.env.KC_TEST_DB_RESET !== '1') throw new Error('E2E-Tests löschen kundencenter_e2e – nur über ops/test/run-e2e.sh starten.');
const base = { host: process.env.DB_HOST ?? '127.0.0.1', user: process.env.DB_USER!, password: process.env.DB_PASSWORD! };
const admin = await mysql.createConnection(base);
await admin.query('DROP DATABASE IF EXISTS kundencenter_e2e');
await admin.query('CREATE DATABASE kundencenter_e2e CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci');
await admin.end();
const c = await mysql.createConnection({ ...base, database: 'kundencenter_e2e', multipleStatements: false });
await c.query('CREATE TABLE schema_migrations (name VARCHAR(200) PRIMARY KEY, checksum CHAR(64) NULL, applied_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3))');
const dir = join(process.cwd(), '../../migrations');
for (const f of readdirSync(dir).filter((n) => n.endsWith('.sql')).sort()) {
await c.query('INSERT INTO schema_migrations (name) VALUES (?)', [f]);
for (const st of readFileSync(join(dir, f), 'utf8').replace(/^\s*--.*$/gm, '').split(/;\s*\n/).map((s) => s.trim()).filter(Boolean)) await c.query(st);
}
// Superadmin + bestätigte 2FA (Geheimnis mit dem Dummy-Schlüssel der Testumgebung verschlüsselt)
process.env.DB_NAME = 'kundencenter_e2e';
const { encrypt } = await import('@kc/platform/crypto');
const secret = new OTPAuth.Secret({ size: 20 }).base32;
const id = randomUUID();
await c.query("INSERT INTO users (id, email, name, password_hash, kind, staff_role, status, email_verified_at) VALUES (?,?,?,?, 'staff', 'superadmin', 'active', UTC_TIMESTAMP(3))", [id, 'admin@e2e.example', 'E2E Admin', await hash('e2e-passwort-admin-123')]);
await c.query('INSERT INTO mfa_totp (user_id, secret_enc, confirmed_at) VALUES (?,?,UTC_TIMESTAMP(3))', [id, encrypt(secret)]);
// Feste Ausgangsdaten für Ticket- und Rechnungsablauf (#119): vollständige Firmendaten, Testkunde mit Inhaber, Rechnungsentwurf
await c.query("UPDATE company_settings SET name='E2E Firma GmbH', street='Teststr. 1', zip='12345', city='Teststadt', tax_number='12/345/67890' WHERE id=1");
const org = randomUUID(); const owner = randomUUID(); const draft = randomUUID();
await c.query("INSERT INTO organizations (id, customer_number, name, customer_type) VALUES (?, 'K-E2E1', 'E2E Ablauf GmbH', 'business')", [org]);
await c.query("INSERT INTO billing_profiles (org_id, company, country, billing_email) VALUES (?, 'E2E Ablauf GmbH', 'DE', 'ablauf@e2e.example')", [org]);
await c.query("INSERT INTO users (id, email, name, password_hash, kind, status) VALUES (?, 'ablauf@e2e.example', 'Ablauf Kunde', ?, 'customer', 'active')", [owner, await hash('e2e-passwort-kunde-1')]);
await c.query("INSERT INTO memberships (org_id, user_id, role) VALUES (?,?,'owner')", [org, owner]);
await c.query("INSERT INTO invoices (id, org_id, status, total_net_cents, total_tax_cents, total_gross_cents, created_by) VALUES (?, ?, 'draft', 1000, 190, 1190, ?)", [draft, org, id]);
await c.query("INSERT INTO invoice_items (id, invoice_id, description, quantity, unit_price_net_cents, tax_bp, net_cents, tax_cents, gross_cents, sort_order) VALUES (?, ?, 'E2E Webhosting', 1, 1000, 1900, 1000, 190, 1190, 0)", [randomUUID(), draft]);
await c.end();
writeFileSync('/tmp/kc-e2e-data.json', JSON.stringify({ draftInvoiceId: draft, customerEmail: 'ablauf@e2e.example', customerPassword: 'e2e-passwort-kunde-1' }));
rmSync('/tmp/kc-e2e-totp-step', { force: true });
writeFileSync('/tmp/kc-e2e-admin.json', JSON.stringify({ email: 'admin@e2e.example', password: 'e2e-passwort-admin-123', secret }));
}
await setup();

View file

@ -0,0 +1,144 @@
import { expect, test } from '@playwright/test';
import { readFileSync } from 'node:fs';
import { admin, expectAccessible, loginStaff, logout, totp } from './helpers';
test.describe.configure({ mode: 'serial' });
test('Login-Seite: barrierefrei, per Tastatur bedienbar, falsches Passwort verständlich abgewiesen', async ({ page }) => {
await page.goto('/login');
await expectAccessible(page, 'Login');
await expect(page.getByLabel('E-Mail')).toBeFocused(); // autoFocus
await page.keyboard.type(admin().email);
await page.keyboard.press('Tab'); await expect(page.getByLabel('Passwort')).toBeFocused();
await page.keyboard.type('falsches-passwort-123');
await page.keyboard.press('Enter');
await expect(page.getByRole('alert').or(page.locator('.alert'))).toBeVisible();
await expect(page).toHaveURL(/\/login/);
});
test('Personal: Anmeldung mit 2FA, Dashboard barrierefrei, Abmelden beendet die Sitzung', async ({ page }) => {
await loginStaff(page);
await expect(page.getByRole('heading', { level: 1 })).toBeVisible();
await expectAccessible(page, 'Dashboard');
await logout(page);
await expect(page).toHaveURL(/\/login/);
await page.goto('/dashboard');
await expect(page).toHaveURL(/\/login/); // geschützte Seite ohne Sitzung
});
test('Kundenanlage → Einladung → Kundenlogin; Kunde sieht nur die eigene Organisation', async ({ page, browser }, info) => {
const suffix = info.project.name;
await loginStaff(page);
const mk = async (name: string, mail: string) => {
await page.goto('/admin/kunden');
await page.getByRole('button', { name: 'Kunde anlegen' }).first().click();
await page.getByLabel('Firmenname').fill(name);
await page.getByLabel('Name', { exact: true }).fill(`Inhaber ${name}`);
await page.getByLabel('E-Mail', { exact: true }).fill(mail);
await page.locator('form').getByRole('button', { name: 'Kunde anlegen' }).click();
const link = await page.locator('code').filter({ hasText: '/einladung' }).textContent();
expect(link).toContain('token=');
return link!;
};
const invA = await mk(`E2E Kunde A ${suffix}`, `a-${suffix}@e2e.example`);
await mk(`E2E Kunde B ${suffix}`, `b-${suffix}@e2e.example`);
await expectAccessible(page, 'Kundenliste');
// Kunde A nimmt die Einladung an (eigener Browser-Kontext = keine Personal-Sitzung)
const ctx = await browser.newContext({ colorScheme: info.project.use.colorScheme, viewport: info.project.use.viewport });
const cp = await ctx.newPage();
await cp.goto(new URL(invA).pathname + new URL(invA).search);
await cp.getByLabel('Passwort', { exact: true }).fill('kunden-passwort-123');
await cp.getByLabel('Passwort wiederholen').fill('kunden-passwort-123');
await cp.getByRole('button', { name: 'Passwort festlegen' }).click();
await cp.goto('/login');
await cp.getByLabel('E-Mail').fill(`a-${suffix}@e2e.example`);
await cp.getByLabel('Passwort').fill('kunden-passwort-123');
await cp.getByRole('button', { name: 'Anmelden' }).click();
await expect(cp).toHaveURL(/\/dashboard/);
await expectAccessible(cp, 'Kunden-Dashboard');
// Mandantentrennung: die Organisationsdaten von Kunde B sind für Kunde A nicht abrufbar
const orgs = await page.request.get('/api/admin/customers?q=' + encodeURIComponent(`E2E Kunde B ${suffix}`));
const list = await orgs.json(); const bId = (Array.isArray(list) ? list : list.items ?? list.customers)[0].id as string;
const me = await (await cp.request.get('/api/auth/me')).json();
const ownOrg = (me.memberships ?? me.user?.memberships ?? [])[0]?.orgId as string | undefined;
if (ownOrg) expect((await cp.request.get(`/api/orgs/${ownOrg}`)).ok()).toBeTruthy();
const foreign = await cp.request.get(`/api/orgs/${bId}`);
expect([403, 404]).toContain(foreign.status());
expect([403, 404]).toContain((await cp.request.get(`/api/orgs/${bId}/members`)).status());
const adminList = await cp.request.get('/api/admin/customers');
expect([401, 403]).toContain(adminList.status());
await ctx.close();
});
test('2FA-Code kann nicht wiederverwendet werden (Replay)', async ({ page }) => {
const a = admin();
await page.goto('/login');
await page.getByLabel('E-Mail').fill(a.email); await page.getByLabel('Passwort').fill(a.password);
await page.getByRole('button', { name: 'Anmelden' }).click();
const code = await totp(a.secret);
await page.getByLabel('Code aus der Authenticator-App').fill(code);
await page.getByRole('button', { name: 'Bestätigen' }).click();
await expect(page).toHaveURL(/\/dashboard/);
await logout(page);
await page.getByLabel('E-Mail').fill(a.email); await page.getByLabel('Passwort').fill(a.password);
await page.getByRole('button', { name: 'Anmelden' }).click();
await page.getByLabel('Code aus der Authenticator-App').fill(code); // derselbe Code
await page.getByRole('button', { name: 'Bestätigen' }).click();
await expect(page).not.toHaveURL(/\/dashboard/);
});
test('Öffentliche Statusseite: ohne Anmeldung erreichbar und barrierefrei', async ({ page }) => {
await page.goto('/status');
await expect(page.getByRole('heading', { name: 'Systemstatus' })).toBeVisible();
await expect(page.getByText('Alle Systeme laufen normal')).toBeVisible();
await expectAccessible(page, 'Statusseite');
});
test('Registrierungsseite: bei ausgeschalteter Registrierung nur Hinweis, barrierefrei', async ({ page }) => {
await page.goto('/registrieren');
await expect(page.getByText('Eine Selbstregistrierung ist derzeit nicht möglich')).toBeVisible();
await expectAccessible(page, 'Registrierung');
});
const data = () => JSON.parse(readFileSync('/tmp/kc-e2e-data.json', 'utf8')) as { draftInvoiceId: string; customerEmail: string; customerPassword: string };
async function loginCustomer(page: import('@playwright/test').Page) {
const d = data(); await page.goto('/login');
await page.getByLabel('E-Mail').fill(d.customerEmail); await page.getByLabel('Passwort').fill(d.customerPassword);
await page.getByRole('button', { name: 'Anmelden' }).click(); await expect(page).toHaveURL(/\/dashboard/);
}
test('Ticket: Kunde eröffnet, Personal antwortet, Kunde sieht die Antwort (#119)', async ({ page, browser }, info) => {
const subject = `Frage zum Hosting ${info.project.name}`;
const ctx = await browser.newContext({ colorScheme: info.project.use.colorScheme, viewport: info.project.use.viewport }); const cp = await ctx.newPage();
await loginCustomer(cp);
await cp.goto('/tickets'); await cp.getByRole('button', { name: 'Neues Ticket' }).click();
await cp.getByLabel('Betreff').fill(subject); await cp.getByLabel('Anliegen').fill('Wie richte ich mein Postfach ein?');
await cp.getByRole('button', { name: 'Absenden' }).click();
await expect(cp).toHaveURL(/\/tickets\/[0-9a-f-]{36}/); const ticketUrl = new URL(cp.url()).pathname;
await expectAccessible(cp, 'Ticket (Kunde)');
await loginStaff(page); await page.goto(ticketUrl);
await expect(page.getByText('Wie richte ich mein Postfach ein?')).toBeVisible();
await page.getByLabel('Antwort').fill('So geht es: Einstellungen öffnen …'); await page.getByRole('button', { name: 'Absenden' }).click();
await expect(page.getByText('So geht es: Einstellungen öffnen …')).toBeVisible();
await cp.reload(); await expect(cp.getByText('So geht es: Einstellungen öffnen …')).toBeVisible();
await ctx.close();
});
test('Rechnung: Personal stellt aus, Kunde sieht sie mit PDF; Entwurf war für den Kunden unsichtbar (#119)', async ({ page, browser }, info) => {
test.skip(info.project.name !== 'desktop-hell', 'Ausstellen ist einmalig – Ablauf läuft nur im Desktop-Projekt');
const d = data();
const ctx = await browser.newContext(); const cp = await ctx.newPage(); await loginCustomer(cp);
expect((await cp.request.get(`/api/invoices/${d.draftInvoiceId}`)).status()).toBe(404); // Entwurf unsichtbar
await loginStaff(page); await page.goto(`/rechnungen/${d.draftInvoiceId}`);
await page.getByRole('button', { name: 'Ausstellen' }).click();
await expect(page.getByText('Ausgestellt.')).toBeVisible();
await expectAccessible(page, 'Rechnung (Personal)');
await cp.goto('/rechnungen'); await expect(cp.getByText(/RE-\d+/).first()).toBeVisible();
await cp.goto(`/rechnungen/${d.draftInvoiceId}`); await expect(cp.getByRole('link', { name: 'PDF ansehen' })).toBeVisible();
const pdf = await cp.request.get(`/api/invoices/${d.draftInvoiceId}/pdf`); expect(pdf.status()).toBe(200); expect((await pdf.body()).subarray(0, 4).toString()).toBe('%PDF');
await expectAccessible(cp, 'Rechnung (Kunde)');
await ctx.close();
});

38
apps/e2e/tests/helpers.ts Normal file
View file

@ -0,0 +1,38 @@
import { expect, type Page } from '@playwright/test';
import AxeBuilder from '@axe-core/playwright';
import { existsSync, readFileSync, writeFileSync } from 'node:fs';
import * as OTPAuth from 'otpauth';
export const admin = () => JSON.parse(readFileSync('/tmp/kc-e2e-admin.json', 'utf8')) as { email: string; password: string; secret: string };
/** TOTP-Code eines NEUEN 30-s-Fensters: die API lehnt einen bereits benutzten Zeitschritt ab (Replay-Schutz). Der
* zuletzt benutzte Schritt wird in einer Datei gemerkt, weil die Projekte (Desktop/Mobil) in getrennten Prozessen laufen. */
const STEP_FILE = '/tmp/kc-e2e-totp-step';
export async function totp(secret: string): Promise<string> {
const t = new OTPAuth.TOTP({ secret: OTPAuth.Secret.fromBase32(secret), digits: 6, period: 30 });
const last = existsSync(STEP_FILE) ? Number(readFileSync(STEP_FILE, 'utf8')) : -1;
while (Math.floor(Date.now() / 30000) <= last) await new Promise((r) => setTimeout(r, 1000));
writeFileSync(STEP_FILE, String(Math.floor(Date.now() / 30000)));
return t.generate();
}
export async function loginStaff(page: Page) {
const a = admin();
await page.goto('/login');
await page.getByLabel('E-Mail').fill(a.email);
await page.getByLabel('Passwort').fill(a.password);
await page.getByRole('button', { name: 'Anmelden' }).click();
await page.getByLabel('Code aus der Authenticator-App').fill(await totp(a.secret));
await page.getByRole('button', { name: 'Bestätigen' }).click();
await expect(page).toHaveURL(/\/dashboard/);
}
/** Abmelden – mobil liegt der Knopf im Menü „Mehr“ der unteren Navigation. */
export async function logout(page: Page) {
const btn = page.getByRole('button', { name: 'Abmelden' });
if (!(await btn.isVisible())) await page.getByRole('button', { name: 'Mehr' }).click();
await btn.click();
}
/** axe-Prüfung nach WCAG 2.2 AA; schwere und kritische Verstöße lassen den Test scheitern. */
export async function expectAccessible(page: Page, label: string) {
const r = await new AxeBuilder({ page }).withTags(['wcag2a', 'wcag2aa', 'wcag21a', 'wcag21aa', 'wcag22aa']).analyze();
const bad = r.violations.filter((v) => v.impact === 'serious' || v.impact === 'critical');
expect(bad.map((v) => `${label}: ${v.id} (${v.impact}) – ${v.nodes.length}× ${v.nodes[0]?.target.join(' ')}`)).toEqual([]);
}

Binary file not shown.

After

Width:  |  Height:  |  Size: 9.1 KiB

View file

@ -29,7 +29,7 @@ export default function Benutzer() {
{msg && <Alert kind={msg.k}>{msg.t}</Alert>}
{open && <form className="card" onSubmit={create}><h2>Neuer Mitarbeiter</h2><div className="cols">
<Field id="name" label="Name"><input id="name" name="name" required autoFocus /></Field><Field id="email" label="E-Mail"><input id="email" name="email" type="email" required /></Field>
<Field id="role" label="Rolle"><select id="role" name="role"><option value="support">Support</option><option value="accounting">Buchhaltung</option>{priv && <><option value="admin">Administrator</option><option value="superadmin">Superadministrator</option></>}</select></Field></div>
<Field id="role" label="Rolle"><select id="role" name="role"><option value="support">Support</option><option value="accounting">Buchhaltung</option>{priv && <><option value="admin">Administrator</option><option value="superadmin">Superadministrator</option><option value="management">Management (nur Auswertung)</option></>}</select></Field></div>
<p className="small muted">Mitarbeiter müssen bei der ersten Anmeldung 2FA einrichten.</p><button className="btn primary" type="submit">Einladung senden</button></form>}
{resetFor && <div className="card" role="alertdialog" aria-labelledby="rt"><p id="rt"><strong>2FA von {resetFor.name} zurücksetzen?</strong> Alle Sitzungen des Benutzers werden beendet. Bitte nur nach Prüfung der Identität ausführen. Die Aktion wird protokolliert.</p>
<div className="row"><button className="btn danger" onClick={() => resetMfa(resetFor)}>Ja, zurücksetzen</button><button className="btn" onClick={() => setResetFor(null)}>Abbrechen</button></div></div>}

View file

@ -3,9 +3,9 @@ import Link from 'next/link';
import { DomainRecords } from '@/components/DomainRecords';
export default function Aufstellung() {
return (<>
return (<div className="page-wide">
<div className="row between"><h1>Domain-Aufstellung</h1><Link className="btn" href="/admin/produkte/domains">Preisliste &amp; Aufschlag</Link></div>
<p className="muted">Je Domain: <strong>Einkauf</strong> (Preisliste von KCS, dort Bruttopreise inkl. USt; netto herausgerechnet) und Ihr <strong>errechneter Verkaufspreis</strong> brutto und netto. Die USt wird nicht doppelt aufgeschlagen. Damit sehen Sie, was Sie bei KCS bestellen müssen und was Sie berechnen.</p>
<DomainRecords />
</>);
</div>);
}

View file

@ -7,7 +7,7 @@ import { useSession } from '@/lib/session';
import { SecretField } from '@/components/SecretField';
import { DomainRecords } from '@/components/DomainRecords';
import { InvoiceList } from '@/components/InvoiceList';
import { Alert, ContractStatusBadge, Empty, Field, fmt, OrderStatusBadge, ResState, ROLE_LABEL, Status } from '@/components/ui';
import { Alert, ContractStatusBadge, Empty, Field, fmt, OrderStatusBadge, ResState, ROLE_LABEL, Status, fmtDate } from '@/components/ui';
interface Org { id: string; name: string; customerNumber: string; customerType: 'private' | 'business'; status: string; billing: Record<string, string | null>; members: { id: string; email: string; name: string; status: string; role: string }[] }
interface CRow { id: string; number: string; status: string; productName: string; termEnd: string | null; cancelEffectiveAt: string | null }
@ -16,7 +16,7 @@ interface RRow { id: string; name: string; state: string; validUntil: string | n
export default function Kunde() {
const { id } = useParams<{ id: string }>(); const { can, reload } = useSession(); const r = useRouter();
const [contracts, setContracts] = useState<CRow[] | null>(null); const [orders, setOrders] = useState<ORow[] | null>(null); const [ress, setRess] = useState<RRow[] | null>(null);
const [o, setO] = useState<Org | null>(null); const [msg, setMsg] = useState<{ k: 'ok' | 'err' | 'warn'; t: string } | null>(null); const [confirm, setConfirm] = useState<string | null>(null); const [switchTo, setSwitchTo] = useState<'private' | 'business' | null>(null);
const [o, setO] = useState<Org | null>(null); const [msg, setMsg] = useState<{ k: 'ok' | 'err' | 'warn'; t: string } | null>(null); const [confirm, setConfirm] = useState<string | null>(null); const [switchTo, setSwitchTo] = useState<'private' | 'business' | null>(null); const [editUser, setEditUser] = useState<string | null>(null);
const [impersonateOpen, setImpersonateOpen] = useState(false); const [impersonateBusy, setImpersonateBusy] = useState(false);
const [welcomeBusy, setWelcomeBusy] = useState(false);
const load = useCallback(() => api<Org>('GET', `/admin/customers/${id}`).then(setO).catch((e) => setMsg({ k: 'err', t: errMsg(e) })), [id]);
@ -33,6 +33,16 @@ export default function Kunde() {
// Beim Wechsel zum Privatkunden werden Firma und USt-IdNr. entfernt (Bestätigung vorher).
try { setO(await api<Org>('PATCH', `/admin/customers/${id}`, { customerType: t, ...(t === 'private' ? { billing: { company: '', vatId: '' } } : { billing: { company: o!.name } }) })); setSwitchTo(null); setMsg({ k: 'ok', t: 'Kundenart geändert.' }); } catch (x) { setMsg({ k: 'err', t: errMsg(x) }); }
}
async function saveUser(e: FormEvent<HTMLFormElement>, m: { id: string; email: string; name: string; status: string }) {
e.preventDefault(); const f = new FormData(e.currentTarget); const email = String(f.get('uemail') ?? '').trim(); const name = String(f.get('uname') ?? '').trim();
try {
await api('PATCH', `/admin/users/${m.id}`, { name, email });
if (f.get('ubilling') === 'on') await api('PATCH', `/admin/customers/${id}`, { billing: { billingEmail: email } });
setEditUser(null); await load();
const changed = email.toLowerCase() !== m.email;
setMsg({ k: 'ok', t: changed ? `Gespeichert. Anmeldung ab sofort mit ${email}${m.status === 'invited' ? ' – die alte Einladung ist ungültig, bitte „Einladung senden“ erneut ausführen.' : '; bestehende Sitzungen wurden beendet.'}` : 'Gespeichert.' });
} catch (x) { setMsg({ k: 'err', t: errMsg(x) }); }
}
async function reinvite(uid: string, email: string) {
try { const r = await api<{ mail: string; inviteLink?: string }>('POST', `/admin/users/${uid}/reinvite`); setMsg(r.mail === 'sent' ? { k: 'ok', t: `Die Einladung wurde an ${email} gesendet.` } : { k: 'warn', t: `E-Mail-Versand ist nicht eingerichtet. Einladungslink (wird nur jetzt angezeigt): ${r.inviteLink}` }); } catch (x) { setMsg({ k: 'err', t: errMsg(x) }); }
}
@ -62,6 +72,10 @@ export default function Kunde() {
<Field id="reason" label="Grund" hint="Pflichtfeld, erscheint im Audit-Protokoll"><input id="reason" name="reason" required minLength={3} maxLength={300} autoFocus /></Field>
<div className="row"><button className="btn primary" type="submit" disabled={impersonateBusy}>{impersonateBusy ? '…' : 'Ansicht wechseln'}</button><button className="btn" type="button" onClick={() => setImpersonateOpen(false)}>Abbrechen</button></div>
</form>}
{w && <div className="card"><h2>Kundenangaben bei Anbietern</h2>
<p className="small muted">Name, Kundennummer und Inhaber werden bei Änderungen automatisch an die Lizenzen dieses Kunden übertragen (soweit der Anbieter das unterstützt). Bei einem Löschanspruch lassen sich die personenbezogenen Angaben dort leeren; Bestell- und Vertragsnummern bleiben beim Anbieter erhalten.</p>
<div className="row"><button className="btn" type="button" onClick={async () => { try { await api('POST', `/admin/customers/${id}/provider-sync`, { mode: 'update' }); setMsg({ k: 'ok', t: 'Abgleich eingeplant (siehe Aufträge).' }); } catch (x) { setMsg({ k: 'err', t: errMsg(x) }); } }}>Jetzt abgleichen</button>
<button className="btn danger" type="button" onClick={async () => { if (!window.confirm('Personenbezogene Kundenangaben (Name, Ansprechpartner, E-Mail, Kundennummer) an allen Lizenzen dieses Kunden beim Anbieter leeren?')) return; try { await api('POST', `/admin/customers/${id}/provider-sync`, { mode: 'erase' }); setMsg({ k: 'ok', t: 'Löschung beim Anbieter eingeplant (siehe Aufträge).' }); } catch (x) { setMsg({ k: 'err', t: errMsg(x) }); } }}>Angaben beim Anbieter löschen</button></div></div>}
<form className="card" onSubmit={save}><h2>Stammdaten &amp; Rechnungsanschrift</h2>
<div className="cols"><Field id="name" label={o.customerType === 'business' ? 'Firmenname' : 'Name'}><input id="name" name="name" defaultValue={o.name} disabled={!w} required /></Field>
{o.customerType === 'business' && <Field id="company" label="Firma (Rechnung)"><input id="company" name="company" defaultValue={o.billing.company ?? ''} disabled={!w} /></Field>}
@ -75,11 +89,11 @@ export default function Kunde() {
<div className="card"><div className="row between"><h2>Verträge</h2>{can('orders.write') && <Link className="btn small" href="/bestellen">Bestellung anlegen</Link>}</div>
{contracts === null ? <p className="muted" role="status">Wird geladen …</p> : contracts.length === 0 ? <Empty title="Noch keine Verträge" /> :
<div className="tablewrap"><table><thead><tr><th>Nr.</th><th>Produkt</th><th>Laufzeit bis</th><th>Status</th></tr></thead><tbody>
{contracts.map((c) => <tr key={c.id}><td className="mono"><Link href={`/vertraege/${c.id}`}>{c.number}</Link></td><td>{c.productName}</td><td>{c.termEnd ? fmt(c.termEnd) : 'unbefristet'}{c.cancelEffectiveAt && <div className="small"><span className="badge warn"><span aria-hidden="true">▲</span>Gekündigt zum {fmt(c.cancelEffectiveAt)}</span></div>}</td><td><ContractStatusBadge value={c.status} /></td></tr>)}</tbody></table></div>}</div>
<div className="card"><h2>Ressourcen und Lizenzen</h2>
{contracts.map((c) => <tr key={c.id}><td className="mono"><Link href={`/vertraege/${c.id}`}>{c.number}</Link></td><td>{c.productName}</td><td>{c.termEnd ? fmtDate(c.termEnd) : 'unbefristet'}{c.cancelEffectiveAt && <div className="small"><span className="badge warn"><span aria-hidden="true">▲</span>Gekündigt zum {fmtDate(c.cancelEffectiveAt)}</span></div>}</td><td><ContractStatusBadge value={c.status} /></td></tr>)}</tbody></table></div>}</div>
<div className="card"><h2>Hosting und Lizenzen</h2>
{ress === null ? <p className="muted" role="status">Wird geladen …</p> : ress.length === 0 ? <Empty title="Keine Ressourcen zugeordnet" /> :
<div className="tablewrap"><table><thead><tr><th>Name</th><th>Status</th><th>Gültig bis</th><th>Lizenzschlüssel</th></tr></thead><tbody>
{ress.map((r) => <tr key={r.id}><td><Link href={`/ressourcen/${r.id}`}>{r.name}</Link>{r.stale && <> <span className="badge warn"><span aria-hidden="true">▲</span>Veraltet</span></>}</td><td><ResState value={r.state} /></td><td>{r.validUntil ? fmt(r.validUntil) : 'unbefristet'}</td><td>{r.canReveal ? <SecretField resourceId={r.id} compact /> : <span className="muted small">–</span>}</td></tr>)}</tbody></table></div>}</div>
{ress.map((r) => <tr key={r.id}><td><Link href={`/ressourcen/${r.id}`}>{r.name}</Link>{r.stale && <> <span className="badge warn"><span aria-hidden="true">▲</span>Veraltet</span></>}</td><td><ResState value={r.state} /></td><td>{r.validUntil ? fmtDate(r.validUntil) : 'unbefristet'}</td><td>{r.canReveal ? <SecretField resourceId={r.id} compact /> : <span className="muted small">–</span>}</td></tr>)}</tbody></table></div>}</div>
{can('domains.read') && <section aria-labelledby="h-dom"><h2 id="h-dom">Domains</h2><DomainRecords orgId={String(id)} /></section>}
{can('invoices.read') && <section aria-labelledby="h-inv"><InvoiceList orgId={String(id)} /></section>}
<div className="card"><h2>Bestellungen</h2>
@ -89,7 +103,14 @@ export default function Kunde() {
<div className="card"><div className="row between"><h2>Benutzer</h2>{w && <button className="btn small" disabled={welcomeBusy} onClick={sendWelcome}>{welcomeBusy ? 'Bitte warten …' : 'Begrüßungsmail senden'}</button>}</div>
<p className="muted small">Enthält den Zugangslink, die aktuellen Produkte mit Preisen und eine kurze Anleitung inkl. Discord-Verknüpfung. Geht an den ersten Ansprechpartner.</p>
<div className="tablewrap"><table><thead><tr><th>Name</th><th>E-Mail</th><th>Rolle</th><th>Status</th><th><span className="sr">Aktionen</span></th></tr></thead><tbody>
{o.members.map((m) => <tr key={m.id}><td>{m.name}</td><td>{m.email}</td><td>{ROLE_LABEL[m.role]}</td><td><Status value={m.status} /></td><td>{w && m.status === 'invited' && <button className="btn small" onClick={() => reinvite(m.id, m.email)}>Einladung senden</button>}</td></tr>)}</tbody></table></div></div>
{o.members.map((m) => editUser === m.id ? <tr key={m.id}><td colSpan={5}>
<form onSubmit={(e) => void saveUser(e, m)}>
<div className="cols"><Field id={`un-${m.id}`} label="Name"><input id={`un-${m.id}`} name="uname" required maxLength={150} defaultValue={m.name} /></Field>
<Field id={`ue-${m.id}`} label="Anmelde-E-Mail" hint="Offene Einladungs- und Passwort-Links werden dabei ungültig, bestehende Sitzungen beendet."><input id={`ue-${m.id}`} name="uemail" type="email" required maxLength={254} defaultValue={m.email} /></Field></div>
{o.billing.billingEmail === m.email && <label className="row small" style={{ marginBottom: 12 }}><input type="checkbox" name="ubilling" defaultChecked style={{ width: 20, minHeight: 20 }} />Rechnungs-E-Mail ebenfalls ändern</label>}
<div className="row"><button className="btn primary small" type="submit">Speichern</button><button className="btn small" type="button" onClick={() => setEditUser(null)}>Abbrechen</button></div>
</form></td></tr>
: <tr key={m.id}><td>{m.name}</td><td>{m.email}</td><td>{ROLE_LABEL[m.role]}</td><td><Status value={m.status} /></td><td><div className="row" style={{ gap: 8 }}>{can('users.write') && <button className="btn small" onClick={() => setEditUser(m.id)}>Bearbeiten</button>}{w && m.status === 'invited' && <button className="btn small" onClick={() => reinvite(m.id, m.email)}>Einladung senden</button>}</div></td></tr>)}</tbody></table></div></div>
{w && <div className="card"><h2>Kundenart</h2>
{switchTo ? (<div role="alertdialog" aria-labelledby="st"><p id="st"><strong>Zu {switchTo === 'private' ? 'Privatkunde' : 'Geschäftskunde'} wechseln?</strong> {switchTo === 'private' ? 'Firma und USt-IdNr. werden entfernt.' : 'Als Firma wird der bisherige Name übernommen.'} Das kann Auswirkungen auf Rechnungen und Steuer haben. Die Änderung wird protokolliert.</p>
<div className="row"><button className="btn primary" onClick={() => changeType(switchTo)}>Ja, ändern</button><button className="btn" onClick={() => setSwitchTo(null)}>Abbrechen</button></div></div>)

View file

@ -5,6 +5,30 @@ import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Empty, Field, Status } from '@/components/ui';
interface Reg { userId: string; email: string; name: string; verifiedAt: string; orgId: string; orgName: string; customerNumber: string; customerType: string }
/** Selbstregistrierung (#36): Einstellung (Superadmin) und Freigabeliste. Standard: aus, Freischaltung durch Personal. */
function Registrierungen() {
const { can } = useSession();
const [cfg, setCfg] = useState<{ enabled: boolean; approval: 'manual' | 'auto' } | null>(null); const [regs, setRegs] = useState<Reg[]>([]); const [msg, setMsg] = useState<{ k: 'ok' | 'err'; t: string } | null>(null);
const load = useCallback(() => { api<typeof cfg>('GET', '/admin/registration-settings').then(setCfg).catch(() => undefined); api<Reg[]>('GET', '/admin/registrations').then(setRegs).catch(() => undefined); }, []);
useEffect(() => { load(); }, [load]);
const save = async (next: { enabled: boolean; approval: 'manual' | 'auto' }) => { try { setCfg(await api('PUT', '/admin/registration-settings', next)); setMsg({ k: 'ok', t: 'Gespeichert.' }); } catch (x) { setMsg({ k: 'err', t: errMsg(x) }); } };
const decide = async (r: Reg, d: 'approve' | 'reject') => { try { await api('POST', `/admin/registrations/${r.userId}/${d}`); setMsg({ k: 'ok', t: d === 'approve' ? `${r.orgName} freigeschaltet.` : `${r.orgName} abgelehnt.` }); load(); } catch (x) { setMsg({ k: 'err', t: errMsg(x) }); } };
if (!cfg) return null;
if (!cfg.enabled && regs.length === 0 && !can('settings.write')) return null;
return (<div className="card"><h2>Selbstregistrierung</h2>
{msg && <Alert kind={msg.k}>{msg.t}</Alert>}
<p className="small muted">Status: {cfg.enabled ? 'eingeschaltet' : 'aus'} · Freischaltung: {cfg.approval === 'auto' ? 'automatisch nach E-Mail-Bestätigung' : 'durch das Personal'}</p>
{can('settings.write') && <div className="row" style={{ gap: 16, flexWrap: 'wrap' }}>
<label className="row" style={{ gap: 8 }}><input type="checkbox" checked={cfg.enabled} onChange={(e) => void save({ ...cfg, enabled: e.target.checked })} style={{ width: 20, minHeight: 20 }} />Registrierung über die Anmeldeseite erlauben</label>
<label className="row" style={{ gap: 8 }}><input type="checkbox" checked={cfg.approval === 'auto'} onChange={(e) => void save({ ...cfg, approval: e.target.checked ? 'auto' : 'manual' })} style={{ width: 20, minHeight: 20 }} />Ohne Prüfung freischalten</label></div>}
{regs.length > 0 && <div className="tablewrap"><table><thead><tr><th>Kunde</th><th>Art</th><th>E-Mail</th><th>Bestätigt</th><th></th></tr></thead><tbody>
{regs.map((r) => <tr key={r.userId}><td>{r.orgName} <span className="muted small">({r.customerNumber})</span></td><td>{r.customerType === 'business' ? 'Geschäftskunde' : 'Privatkunde'}</td><td>{r.email}</td><td className="small">{new Date(r.verifiedAt).toLocaleString('de-DE', { dateStyle: 'short', timeStyle: 'short' })}</td>
<td>{can('customers.write') && <div className="row" style={{ gap: 8 }}><button className="btn small primary" onClick={() => void decide(r, 'approve')}>Freischalten</button><button className="btn small danger" onClick={() => void decide(r, 'reject')}>Ablehnen</button></div>}</td></tr>)}
</tbody></table></div>}
</div>);
}
interface Cust { id: string; customerNumber: string; name: string; customerType: 'private' | 'business'; status: string; city: string | null; billingEmail: string | null; members: number }
export default function Kunden() {
const { can } = useSession();
@ -26,6 +50,7 @@ export default function Kunden() {
}
return (<>
<div className="row between"><h1>Kunden</h1>{can('customers.write') && <div className="row"><Link className="btn" href="/admin/kunden/uebernahme">Aus Verbindung übernehmen</Link><button className="btn primary" onClick={() => { setOpen(!open); setCreated(null); }} aria-expanded={open}>Kunde anlegen</button></div>}</div>
<Registrierungen />
{err && <Alert kind="err">{err}</Alert>}
{created && <Alert kind={created.mail === 'sent' ? 'ok' : 'warn'}>Kunde {created.customerNumber} angelegt. {created.mail === 'sent' ? 'Die Einladung wurde per E-Mail versendet.' : <>E-Mail-Versand ist nicht eingerichtet. Einladungslink (wird nur jetzt angezeigt): <code>{created.inviteLink}</code></>}</Alert>}
{open && <form className="card" onSubmit={create}><h2>Neuer Kunde</h2>

View file

@ -4,13 +4,14 @@ import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { Alert, Empty, fmt } from '@/components/ui';
interface Msg { id: string; fromEmail: string; fromName: string | null; subject: string | null; bodyText: string | null; receivedAt: string; status: 'unmatched' | 'matched' | 'created' | 'ignored'; ticketId: string | null; ticketNumber: string | null }
interface Msg { id: string; fromEmail: string; fromName: string | null; subject: string | null; bodyText: string | null; receivedAt: string; status: 'unmatched' | 'matched' | 'created' | 'ignored'; ticketId: string | null; ticketNumber: string | null; suggestedTicketNumber: string | null; suggestedOrgId: string | null; processingError: string | null }
interface Cust { id: string; name: string; customerNumber: string }
const STATUS_LABEL: Record<Msg['status'], string> = { unmatched: 'Unzugeordnet', matched: 'An Ticket angehängt', created: 'Ticket erstellt', ignored: 'Ignoriert' };
/** Eine unzugeordnete Mail: Kunde zuweisen (legt neues Ticket an), an bestehendes Ticket anhängen, oder ignorieren. */
function UnmatchedRow({ m, custs, onDone, onError }: { m: Msg; custs: Cust[]; onDone: (t: string) => void; onError: (m: string) => void }) {
const [org, setOrg] = useState(''); const [ticketNumber, setTicketNumber] = useState(''); const [busy, setBusy] = useState(false); const [open, setOpen] = useState(false);
// Vorschläge aus Betreff/Absender nur vorausfüllen – bestätigen muss immer das Personal (Absender ist nicht nachgewiesen)
const [org, setOrg] = useState(m.suggestedOrgId ?? ''); const [ticketNumber, setTicketNumber] = useState(m.suggestedTicketNumber ?? ''); const [busy, setBusy] = useState(false); const [open, setOpen] = useState(false);
async function assign() {
if (!org) return; setBusy(true);
try { const r = await api<{ number: string }>('POST', `/admin/inbox/${m.id}/assign`, { orgId: org }); onDone(`Ticket ${r.number} angelegt.`); }
@ -29,6 +30,8 @@ function UnmatchedRow({ m, custs, onDone, onError }: { m: Msg; custs: Cust[]; on
return (<div className="card">
<div className="row between"><div><strong>{m.subject || '(kein Betreff)'}</strong><p className="small muted" style={{ margin: '2px 0 0' }}>Von: {m.fromName ? `${m.fromName} <${m.fromEmail}>` : m.fromEmail} · {fmt(m.receivedAt)}</p></div>
<button className="btn small" aria-expanded={open} onClick={() => setOpen(!open)}>{open ? 'Schließen' : 'Text anzeigen'}</button></div>
{(m.suggestedTicketNumber || m.suggestedOrgId) && <p className="small muted" style={{ margin: '8px 0 0' }}>Vorschlag aus Betreff/Absender vorausgefüllt. Der Absender ist nicht nachgewiesen (keine Antwort auf eine Kundencenter-Mail) – bitte prüfen, bevor Sie zuordnen.</p>}
{m.processingError && <p className="small" style={{ margin: '8px 0 0', color: 'var(--err)' }}>Automatische Verarbeitung fehlgeschlagen: {m.processingError}</p>}
{open && <pre className="small" style={{ whiteSpace: 'pre-wrap', background: 'var(--surface-2)', padding: 12, borderRadius: 'var(--radius-sm)', margin: '12px 0', maxHeight: 300, overflow: 'auto' }}>{m.bodyText || '(kein Text)'}</pre>}
<div className="row" style={{ marginTop: 12, gap: 16, flexWrap: 'wrap' }}>
<div className="row" style={{ gap: 8 }}>

View file

@ -0,0 +1,53 @@
'use client';
import { useCallback, useEffect, useState, type FormEvent } from 'react';
import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Empty, Field, fmt } from '@/components/ui';
interface Ev { id: string; kind: 'incident' | 'maintenance'; title: string; component: string | null; impact: string; state: string; startsAt: string; endsAt: string | null; published?: boolean; updates: { state: string; body: string; at: string }[] }
const STATES = { incident: [['investigating', 'Wird untersucht'], ['identified', 'Ursache gefunden'], ['monitoring', 'Wird beobachtet'], ['resolved', 'Behoben']], maintenance: [['planned', 'Geplant'], ['in_progress', 'Läuft'], ['completed', 'Abgeschlossen']] } as const;
function Row({ e, onDone }: { e: Ev; onDone: (m: { k: 'ok' | 'err'; t: string }) => void }) {
const [busy, setBusy] = useState(false);
async function update(ev: FormEvent<HTMLFormElement>) {
ev.preventDefault(); setBusy(true); const f = new FormData(ev.currentTarget);
try { await api('POST', `/admin/status-events/${e.id}/update`, { state: f.get('state'), body: String(f.get('body') ?? '').trim() || undefined, published: f.get('published') === 'on' }); onDone({ k: 'ok', t: 'Gespeichert.' }); (ev.target as HTMLFormElement).reset(); }
catch (x) { onDone({ k: 'err', t: errMsg(x) }); } finally { setBusy(false); }
}
return (<form className="card" onSubmit={update}>
<strong>{e.title}</strong> <span className="small muted">({e.kind === 'incident' ? 'Störung' : 'Wartung'}{e.component ? `, ${e.component}` : ''}, Auswirkung {e.impact}, seit {fmt(e.startsAt)})</span>
<ul className="small" style={{ paddingLeft: 18 }}>{e.updates.map((u, i) => <li key={i}>{u.state} ({fmt(u.at)}): {u.body}</li>)}</ul>
<div className="cols"><Field id={`s-${e.id}`} label="Zustand"><select id={`s-${e.id}`} name="state" defaultValue={e.state}>{STATES[e.kind].map(([v, l]) => <option key={v} value={v}>{l}</option>)}</select></Field>
<Field id={`b-${e.id}`} label="Neue Meldung (öffentlich, wenn veröffentlicht)"><input id={`b-${e.id}`} name="body" maxLength={2000} /></Field></div>
<label className="row" style={{ gap: 8, margin: '4px 0 12px' }}><input type="checkbox" name="published" defaultChecked={!!e.published} style={{ width: 20, minHeight: 20 }} />Auf der Statusseite veröffentlicht</label>
<button className="btn small" disabled={busy} type="submit">Speichern</button>
</form>);
}
/** Verwaltung der öffentlichen Statusseite (#23). Nur eigene Texte, keine Kunden- oder Anbieterdetails eintragen. */
export default function StatusAdmin() {
const { can } = useSession();
const [list, setList] = useState<Ev[] | null>(null); const [msg, setMsg] = useState<{ k: 'ok' | 'err'; t: string } | null>(null); const [kind, setKind] = useState<'incident' | 'maintenance'>('incident');
const load = useCallback(() => api<Ev[]>('GET', '/admin/status-events').then(setList).catch((e) => setMsg({ k: 'err', t: errMsg(e) })), []);
useEffect(() => { void load(); }, [load]);
async function create(ev: FormEvent<HTMLFormElement>) {
ev.preventDefault(); const f = new FormData(ev.currentTarget); const v = (k: string) => String(f.get(k) ?? '').trim() || undefined;
try { await api('POST', '/admin/status-events', { kind, title: v('title'), component: v('component'), impact: f.get('impact'), startsAt: v('startsAt'), endsAt: v('endsAt'), body: v('body'), published: f.get('published') === 'on' }); setMsg({ k: 'ok', t: 'Angelegt.' }); (ev.target as HTMLFormElement).reset(); void load(); }
catch (x) { setMsg({ k: 'err', t: errMsg(x) }); }
}
const w = can('status.write');
return (<>
<div className="row between"><h1>Statusseite</h1><Link className="btn" href="/status" target="_blank">Öffentliche Ansicht</Link></div>
<p className="muted">Öffentlich sichtbar ist nur, was hier veröffentlicht wird. Bitte keine Kundennamen, Ressourcen oder internen Details eintragen.</p>
{msg && <Alert kind={msg.k}>{msg.t}</Alert>}
{w && <form className="card" onSubmit={create}><h2>Neuer Eintrag</h2>
<div className="row" style={{ marginBottom: 12 }}>{([['incident', 'Störung'], ['maintenance', 'Wartung']] as const).map(([k, l]) => <label key={k} className="row"><input type="radio" name="kind" checked={kind === k} onChange={() => setKind(k)} style={{ width: 20, minHeight: 20 }} />{l}</label>)}</div>
<div className="cols"><Field id="title" label="Titel"><input id="title" name="title" required minLength={3} maxLength={200} /></Field><Field id="component" label="Bereich (optional)" hint="z. B. Webhosting, E-Mail, Kundencenter"><input id="component" name="component" maxLength={100} /></Field>
<Field id="impact" label="Auswirkung"><select id="impact" name="impact" defaultValue="minor"><option value="none">keine</option><option value="minor">teilweise</option><option value="major">größere Störung</option></select></Field></div>
{kind === 'maintenance' && <div className="cols"><Field id="startsAt" label="Beginn"><input id="startsAt" name="startsAt" type="datetime-local" required /></Field><Field id="endsAt" label="Ende (geplant)"><input id="endsAt" name="endsAt" type="datetime-local" /></Field></div>}
<Field id="body" label="Erste Meldung"><input id="body" name="body" required minLength={3} maxLength={2000} /></Field>
<label className="row" style={{ gap: 8, margin: '4px 0 12px' }}><input type="checkbox" name="published" style={{ width: 20, minHeight: 20 }} />Sofort veröffentlichen</label>
<button className="btn primary" type="submit">Anlegen</button></form>}
{list === null ? <p className="muted" role="status">Wird geladen …</p> : list.length === 0 ? <div className="card"><Empty title="Noch keine Einträge" /></div> : list.map((e) => <Row key={e.id} e={e} onDone={(m) => { setMsg(m); void load(); }} />)}
</>);
}

View file

@ -0,0 +1,48 @@
'use client';
import { useCallback, useEffect, useState } from 'react';
import { api, errMsg } from '@/lib/api';
import { Alert, Field, eur } from '@/components/ui';
interface Money { count: number; netCents: number; taxCents: number; grossCents: number }
interface Sum {
period: { from: string; to: string; basis: string }; currency: string; dataAsOf: string;
customers: { activeNow: number; suspendedNow: number; createdInPeriod: number }; contracts: { activeNow: number; createdInPeriod: number; endedInPeriod: number };
invoices: { issued: Money; credits: Money; netAfterCreditsCents: number; grossAfterCreditsCents: number; markedPaid: Money; open: Money; overdueNow: Money };
byTaxRate: { taxBp: number; netCents: number; taxCents: number; grossCents: number }[]; byCategory: { category: string; netCents: number; grossCents: number }[];
byMonth: { month: string; issuedNetCents: number; creditNetCents: number; netAfterCreditsCents: number }[]; definitions: string[];
}
const CAT: Record<string, string> = { hosting: 'Hosting', license: 'Lizenzen', addon: 'Zusatzleistungen', service: 'Dienstleistungen', ohne_vertrag: 'ohne Vertragsbezug' };
const iso = (d: Date) => d.toISOString().slice(0, 10);
const Tile = ({ label, value, sub }: { label: string; value: string; sub?: string }) => <div className="card"><p className="small muted" style={{ margin: 0 }}>{label}</p><p style={{ fontSize: '1.4rem', fontWeight: 700, margin: '4px 0' }}>{value}</p>{sub && <p className="small muted" style={{ margin: 0 }}>{sub}</p>}</div>;
/** Management-Auswertung (#133): nur lesend, Rolle „Management“. */
export default function Auswertung() {
const now = new Date(); const [from, setFrom] = useState(iso(new Date(Date.UTC(now.getUTCFullYear(), 0, 1)))); const [to, setTo] = useState(iso(now));
const [s, setS] = useState<Sum | null>(null); const [err, setErr] = useState('');
const load = useCallback(() => { setErr(''); api<Sum>('GET', `/analytics/summary?from=${from}&to=${to}`).then(setS).catch((e) => setErr(errMsg(e))); }, [from, to]);
useEffect(() => { load(); }, [load]);
return (<>
<h1>Auswertung</h1>
<div className="card"><div className="cols"><Field id="from" label="Von (Rechnungsdatum)"><input id="from" type="date" value={from} onChange={(e) => setFrom(e.target.value)} /></Field><Field id="to" label="Bis einschließlich"><input id="to" type="date" value={to} onChange={(e) => setTo(e.target.value)} /></Field></div></div>
{err && <Alert kind="err">{err}</Alert>}
{!s ? <p className="muted" role="status">Wird geladen …</p> : (<>
<p className="small muted">Datenstand {new Date(s.dataAsOf).toLocaleString('de-DE')} · Beträge in {s.currency} · {s.period.basis}</p>
<div className="grid">
<Tile label="Aktive Kunden (jetzt)" value={String(s.customers.activeNow)} sub={`${s.customers.createdInPeriod} neu im Zeitraum, ${s.customers.suspendedNow} gesperrt`} />
<Tile label="Aktive Verträge (jetzt)" value={String(s.contracts.activeNow)} sub={`${s.contracts.createdInPeriod} neu, ${s.contracts.endedInPeriod} beendet im Zeitraum`} />
<Tile label="Ausgestellt (netto)" value={eur(s.invoices.issued.netCents)} sub={`${s.invoices.issued.count} Rechnungen · brutto ${eur(s.invoices.issued.grossCents)}`} />
<Tile label="Stornos (netto)" value={eur(s.invoices.credits.netCents)} sub={`${s.invoices.credits.count} Stornorechnungen`} />
<Tile label="Netto nach Storno" value={eur(s.invoices.netAfterCreditsCents)} sub={`brutto ${eur(s.invoices.grossAfterCreditsCents)}`} />
<Tile label="Als bezahlt markiert (brutto)" value={eur(s.invoices.markedPaid.grossCents)} sub="Rechnungsstatus, kein gebuchter Zahlungseingang" />
<Tile label="Offen (brutto)" value={eur(s.invoices.open.grossCents)} sub={`davon überfällig ${eur(s.invoices.overdueNow.grossCents)}`} />
</div>
<div className="card"><h2>Nach Produktkategorie</h2><div className="tablewrap"><table><thead><tr><th>Kategorie</th><th>Netto</th><th>Brutto</th></tr></thead><tbody>
{s.byCategory.map((c) => <tr key={c.category}><td>{CAT[c.category] ?? c.category}</td><td>{eur(c.netCents)}</td><td>{eur(c.grossCents)}</td></tr>)}</tbody></table></div></div>
<div className="card"><h2>Nach Steuersatz</h2><div className="tablewrap"><table><thead><tr><th>USt.</th><th>Netto</th><th>Steuer</th><th>Brutto</th></tr></thead><tbody>
{s.byTaxRate.map((t) => <tr key={t.taxBp}><td>{t.taxBp / 100} %</td><td>{eur(t.netCents)}</td><td>{eur(t.taxCents)}</td><td>{eur(t.grossCents)}</td></tr>)}</tbody></table></div></div>
<div className="card"><h2>Nach Monat (netto)</h2><div className="tablewrap"><table><thead><tr><th>Monat</th><th>Ausgestellt</th><th>Stornos</th><th>Nach Storno</th></tr></thead><tbody>
{s.byMonth.map((m) => <tr key={m.month}><td>{m.month}</td><td>{eur(m.issuedNetCents)}</td><td>{eur(m.creditNetCents)}</td><td>{eur(m.netAfterCreditsCents)}</td></tr>)}</tbody></table></div></div>
<div className="card"><h2>So wird gerechnet</h2><ul className="small">{s.definitions.map((d) => <li key={d}>{d}</li>)}</ul></div>
</>)}
</>);
}

View file

@ -16,7 +16,7 @@ export default function Bestellen() {
const selPrice: Price | null = sel && (term === '' ? sel.price : { ...sel.price, recurring: sel.termPrices.find((t) => t.termMonths === term)!.price });
async function order(e: FormEvent<HTMLFormElement>) {
e.preventDefault(); if (!sel) return; setBusy(true); setErr(''); const f = new FormData(e.currentTarget);
try { const o = await api<{ status: string; number: string }>('POST', '/orders', { orgId: org, note: (f.get('note') as string) || undefined, items: [{ productId: sel.id, quantity: 1, ...(term !== '' ? { termMonths: term } : {}), ...(staff ? { discountBp: Math.round(Number(f.get('discount') || 0) * 100) } : {}) }] }); r.push(`/bestellungen?neu=${o.number}`); }
try { const o = await api<{ status: string; number: string }>('POST', '/orders', { orgId: org, note: (f.get('note') as string) || undefined, items: [{ productId: sel.id, quantity: 1, ...(term !== '' ? { termMonths: term } : {}), ...(staff ? { discountBp: Math.round(Number(f.get('discount') || 0) * 100) } : {}) }], domains: String(f.get('domain') ?? '').trim() ? [{ name: String(f.get('domain')).trim() }] : [] }); r.push(`/bestellungen?neu=${o.number}`); }
catch (x) { setErr(errMsg(x)); } finally { setBusy(false); }
}
return (<>
@ -36,6 +36,7 @@ export default function Bestellen() {
</>)}
</div>
{staff && <Field id="discount" label="Rabatt in %" hint="Nur Personal. Der Preis wird serverseitig berechnet."><input id="discount" name="discount" type="number" min={0} max={100} step="0.01" defaultValue={0} /></Field>}
<Field id="domain" label="Domain dazu bestellen (optional)" hint="z. B. meine-firma.de – Preis und Laufzeit laut Domain-Preisliste; die Verfügbarkeit prüfen wir vor der Registrierung. Domains gibt das Personal immer frei."><input id="domain" name="domain" maxLength={253} autoComplete="off" /></Field>
<Field id="note" label="Anmerkung (optional)"><input id="note" name="note" maxLength={500} /></Field>
<p className="small muted">{staff ? 'Die Bestellung wird sofort freigegeben und bereitgestellt.' : sel.requiresApproval ? 'Ihre Bestellung wird von uns geprüft und freigegeben. Sie sehen den Stand unter „Bestellungen“.' : 'Die Bereitstellung startet sofort.'}</p>
<button className="btn primary" disabled={busy} type="submit">{busy ? 'Bitte warten …' : 'Verbindlich bestellen'}</button></form>}

View file

@ -3,9 +3,9 @@ import { useCallback, useEffect, useState } from 'react';
import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Empty, fmt, OrderStatusBadge, type Price, PriceText } from '@/components/ui';
import { Alert, Empty, fmt, OrderStatusBadge, type Price, PriceText, eur } from '@/components/ui';
interface O { id: string; number: string; orgName: string; status: string; createdAt: string; failureNote: string | null; failureAmbiguous: boolean; note: string | null; items: { id: string; quantity: number; contractId: string | null; snapshot: Price & { name: string; customerType: string } }[] }
interface O { id: string; number: string; orgName: string; status: string; createdAt: string; failureNote: string | null; failureAmbiguous: boolean; note: string | null; items: { id: string; quantity: number; contractId: string | null; snapshot: Price & { name: string; customerType: string } }[]; domains?: { domain: string; termMonths: number; setupGrossCents: number; sellNetCents: number; sellGrossCents: number; recorded: boolean }[] }
export default function Bestellungen() {
const { can, me } = useSession(); const staff = can('orders.read'); const approver = can('orders.approve');
const [list, setList] = useState<O[] | null>(null); const [msg, setMsg] = useState<{ k: 'ok' | 'err'; t: string } | null>(null); const [busy, setBusy] = useState(''); const [chk, setChk] = useState<Record<string, boolean>>({});
@ -20,6 +20,7 @@ export default function Bestellungen() {
<div className="card" key={o.id}><div className="row between"><h2 style={{ margin: 0 }}><span className="mono">{o.number}</span>{staff && <span className="muted"> · {o.orgName}</span>}</h2><OrderStatusBadge value={o.status} /></div>
<p className="small muted">Bestellt am {fmt(o.createdAt)}{o.note ? ` · „${o.note}“` : ''}</p>
{o.items.map((i) => <div key={i.id} style={{ marginBottom: 8 }}><strong>{i.quantity} × {i.snapshot.name}</strong>{i.contractId && <> · <Link href={`/vertraege/${i.contractId}`}>Vertrag</Link></>}<div className="small"><PriceText p={i.snapshot} priv={i.snapshot.customerType === 'private'} /></div></div>)}
{(o.domains ?? []).map((d) => <div key={d.domain} style={{ marginBottom: 8 }}><strong>Domain {d.domain}</strong><div className="small">{d.termMonths} Monate: {eur(d.sellGrossCents)} inkl. USt. ({eur(d.sellNetCents)} netto){d.setupGrossCents > 0 ? `, Einrichtung ${eur(d.setupGrossCents)}` : ''}{d.recorded ? ' · in Beschaffung' : ''}</div></div>)}
{o.status === 'failed' && o.failureNote && <Alert kind="err">{o.failureNote}</Alert>}
{o.status === 'provisioning' && <p className="small muted" role="status">Die Bereitstellung läuft im Hintergrund. Diese Seite aktualisiert sich automatisch.</p>}
<div className="row">

View file

@ -3,14 +3,38 @@ import { useEffect, useState } from 'react';
import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Empty } from '@/components/ui';
import { Alert, Empty, InvoiceStatusBadge, TicketStatusBadge, eur, fmt, fmtDay } from '@/components/ui';
interface Drift { contractId: string; contractNumber: string; orgName: string; resourceId: string; resourceName: string; observed: string; expected: string; kind: 'mismatch' | 'uncertain'; reason: string }
interface Sys { jobs: Record<string, number>; oldestPendingJob: string | null; alerts?: { key: string; label: string; since: string; detail: string | null }[]; worker?: { lastHeartbeatSecondsAgo: number | null }; backup?: { configured: boolean; lastRunAt?: string | null; ok?: boolean; ageHours?: number | null; stale?: boolean; error?: string | null; sizeBytes?: number | null; targets?: { name: string; ok: boolean }[]; lastRestoreTestAt?: string | null; restoreOk?: boolean | null; restoreStale?: boolean } }
interface RecentTicket { id: string; number: string; orgName: string; subject: string; status: string; lastMessageAt: string }
interface OpenInvoice { id: string; number: string | null; orgName: string; status: string; overdue: boolean; dueDate: string | null; totalGrossCents: number }
/** Kurzlisten auf der Übersicht: zuletzt aktive Tickets und offene Rechnungen. */
function Recent({ staff, tickets, invoices }: { staff: boolean; tickets: boolean; invoices: boolean }) {
const [t, setT] = useState<RecentTicket[] | null>(null); const [inv, setInv] = useState<OpenInvoice[] | null>(null);
useEffect(() => {
if (tickets) api<RecentTicket[]>('GET', '/tickets').then((l) => setT(l.filter((x) => x.status !== 'resolved' && x.status !== 'closed').sort((a, b) => b.lastMessageAt.localeCompare(a.lastMessageAt)).slice(0, 5))).catch(() => setT([]));
if (invoices) api<OpenInvoice[]>('GET', '/invoices').then((l) => setInv(l.filter((x) => x.status === 'open').sort((a, b) => Number(b.overdue) - Number(a.overdue) || (a.dueDate ?? '').localeCompare(b.dueDate ?? '')).slice(0, 5))).catch(() => setInv([]));
}, [tickets, invoices]);
if (!tickets && !invoices) return null;
return (<div className="grid wide">
{tickets && <section className="card"><div className="row between"><h2>Aktuelle Tickets</h2><Link className="small" href="/tickets">Alle Tickets</Link></div>
{t === null ? <p className="muted small" role="status">Wird geladen …</p> : t.length === 0 ? <p className="muted">Keine offenen Tickets.</p>
: <ul className="list">{t.map((x) => <li key={x.id}><Link href={`/tickets/${x.id}`}><span className="title">{x.subject}</span><span className="meta">{x.number}{staff && ` · ${x.orgName}`} · {fmt(x.lastMessageAt)}</span></Link><TicketStatusBadge value={x.status} /></li>)}</ul>}
</section>}
{invoices && <section className="card"><div className="row between"><h2>Offene Rechnungen</h2><Link className="small" href="/rechnungen">Alle Rechnungen</Link></div>
{inv === null ? <p className="muted small" role="status">Wird geladen …</p> : inv.length === 0 ? <p className="muted">Keine offenen Rechnungen.</p>
: <ul className="list">{inv.map((x) => <li key={x.id}><Link href={`/rechnungen/${x.id}`}><span className="title">{x.number ?? 'Entwurf'} · {eur(x.totalGrossCents)}</span><span className="meta">{staff && `${x.orgName} · `}fällig {x.dueDate ? fmtDay(x.dueDate) : '–'}</span></Link><InvoiceStatusBadge value={x.status} overdue={x.overdue} /></li>)}</ul>}
</section>}
</div>);
}
interface Sys { jobs: Record<string, number>; oldestPendingJob: string | null; backup?: { configured: boolean; lastRunAt?: string | null; ok?: boolean; ageHours?: number | null; stale?: boolean; error?: string | null; sizeBytes?: number | null; targets?: { name: string; ok: boolean }[]; lastRestoreTestAt?: string | null; restoreOk?: boolean | null; restoreStale?: boolean } }
export default function Dashboard() {
const { me, can } = useSession();
const [mine, setMine] = useState<{ contracts: { status: string; cancelEffectiveAt: string | null }[]; resources: { state: string; stale: boolean }[]; orders: { status: string }[] } | null>(null);
const [mine, setMine] = useState<{ contracts: { status: string; cancelEffectiveAt: string | null }[]; resources: { type: string; state: string; stale: boolean }[]; orders: { status: string }[] } | null>(null);
const [licenses, setLicenses] = useState<{ active: number; expiring: number; unassigned: number } | null>(null);
const [customers, setCustomers] = useState<number | null>(null); const [sys, setSys] = useState<Sys | null>(null); const [err, setErr] = useState('');
const [customers, setCustomers] = useState<number | null>(null); const [sys, setSys] = useState<Sys | null>(null); const [drift, setDrift] = useState<Drift[]>([]); const [err, setErr] = useState('');
useEffect(() => {
if (me?.kind === 'customer') {
Promise.all([api<any[]>('GET', '/contracts'), api<any[]>('GET', '/resources'), api<any[]>('GET', '/orders')]).then(([contracts, resources, orders]) => setMine({ contracts, resources, orders })).catch((e) => setErr(errMsg(e)));
@ -19,6 +43,7 @@ export default function Dashboard() {
if (!me || me.kind !== 'staff') return;
if (can('customers.read')) api<unknown[]>('GET', '/admin/customers').then((l) => setCustomers(l.length)).catch((e) => setErr(errMsg(e)));
if (can('jobs.read')) api<Sys>('GET', '/admin/system').then(setSys).catch((e) => setErr(errMsg(e)));
if (can('resources.read')) api<Drift[]>('GET', '/admin/drift').then(setDrift).catch(() => undefined);
if (can('licenses.read')) api<{ active: number; expiring: number; unassigned: number }>('GET', '/admin/licenses/summary').then(setLicenses).catch(() => undefined);
}, [me, can]);
if (!me) return null;
@ -33,7 +58,7 @@ export default function Dashboard() {
{mine && mine.contracts.length === 0 && mine.resources.length === 0 && mine.orders.length === 0 && <div className="card"><Empty title="Noch keine Produkte">Sobald Produkte, Verträge, Rechnungen oder Tickets für Ihre Organisation vorhanden sind, erscheinen sie hier.</Empty></div>}
{mine && (mine.contracts.length > 0 || mine.resources.length > 0 || mine.orders.length > 0) && <div className="grid">
<div className="card"><div className="stat">{mine.contracts.filter((c) => c.status === 'active').length}</div><p className="muted">Aktive Verträge</p>{mine.contracts.some((c) => c.cancelEffectiveAt) && <p className="small"><span className="badge warn"><span aria-hidden="true">▲</span>Gekündigter Vertrag vorhanden</span></p>}<Link href="/vertraege">Verträge ansehen</Link></div>
<div className="card"><div className="stat">{mine.resources.length}</div><p className="muted">Ressourcen und Lizenzen</p>{mine.resources.some((r) => r.stale) && <p className="small"><span className="badge warn"><span aria-hidden="true">▲</span>Stand teilweise veraltet</span></p>}<Link href="/ressourcen">Ressourcen ansehen</Link></div>
<div className="card"><div className="stat">{mine.resources.length}</div><p className="muted">Hosting und Lizenzen</p>{(() => { const lic = mine.resources.filter((r) => r.type === 'license').length; const host = mine.resources.length - lic; return mine.resources.length > 0 && <p className="small muted">{[host > 0 && `${host} Webhosting`, lic > 0 && `${lic} ${lic === 1 ? 'Lizenz' : 'Lizenzen'}`].filter(Boolean).join(' · ')}</p>; })()}{mine.resources.some((r) => r.stale) && <p className="small"><span className="badge warn"><span aria-hidden="true">▲</span>Stand teilweise veraltet</span></p>}<Link href="/ressourcen">Alle ansehen</Link></div>
{mine.orders.filter((o) => ['pending_approval', 'provisioning', 'failed'].includes(o.status)).length > 0 && <div className="card"><div className="stat">{mine.orders.filter((o) => ['pending_approval', 'provisioning', 'failed'].includes(o.status)).length}</div><p className="muted">Bestellungen in Bearbeitung</p><Link href="/bestellungen">Bestellungen ansehen</Link></div>}
</div>}
</>) : (<>
@ -41,6 +66,11 @@ export default function Dashboard() {
{customers !== null && <div className="card"><div className="stat">{customers}</div><p className="muted">Kunden</p><Link href="/admin/kunden">Kunden verwalten</Link></div>}
{licenses && <div className="card"><div className="stat">{licenses.active}</div><p className="muted">Aktive Lizenzen</p>{licenses.expiring > 0 && <p className="small"><span className="badge warn"><span aria-hidden="true">▲</span>{licenses.expiring} laufen in 30 Tagen ab</span></p>}{licenses.unassigned > 0 && <p className="small"><span className="badge warn"><span aria-hidden="true">▲</span>{licenses.unassigned} ohne Kunde</span></p>}<Link href="/lizenzen">Lizenzen verwalten</Link></div>}
{sys && <div className="card"><div className="stat">{sys.jobs.scheduled ?? 0}</div><p className="muted">Wartende Aufträge</p></div>}
{drift.length > 0 && <div className="card"><h3>Abweichungen Vertrag ↔ Anbieter</h3>
<p className="small muted">Nur Anzeige – es wird nichts automatisch zurückgeschrieben.</p>
<ul className="small" style={{ margin: 0, paddingLeft: 18 }}>{drift.map((d) => <li key={d.contractId}><span className={`badge ${d.kind === 'mismatch' ? 'warn' : 'info'}`}><span aria-hidden="true">{d.kind === 'mismatch' ? '▲' : 'ⓘ'}</span>{d.kind === 'mismatch' ? 'Abweichung' : 'ungewiss'}</span> <Link href={`/ressourcen/${d.resourceId}`}>{d.resourceName}</Link> ({d.orgName}, {d.contractNumber}): {d.reason}</li>)}</ul></div>}
{sys?.alerts && sys.alerts.length > 0 && <div className="card" role="alert"><h3>Betriebsalarme</h3>
<ul className="small" style={{ margin: 0, paddingLeft: 18 }}>{sys.alerts.map((a) => <li key={a.key}><strong>{a.label}</strong>{a.detail ? ` – ${a.detail}` : ''} <span className="muted">(seit {new Date(a.since).toLocaleString('de-DE', { dateStyle: 'short', timeStyle: 'short' })})</span></li>)}</ul></div>}
{sys?.backup && <div className="card"><h3>Backup</h3><p className="small"><Link href="/einstellungen/backup">Details und Einstellungen</Link></p>
{!sys.backup.configured ? <><p className="muted">Nicht eingerichtet.</p><span className="badge warn"><span aria-hidden="true">▲</span>Kein Backup</span></>
: <><p>{sys.backup.stale ? <span className="badge err"><span aria-hidden="true">✕</span>{sys.backup.ok ? 'Veraltet' : 'Fehlgeschlagen'}</span> : <span className="badge ok"><span aria-hidden="true">✓</span>Aktuell</span>}</p>
@ -49,5 +79,6 @@ export default function Dashboard() {
{sys && <div className="card"><div className="stat">{failed}</div><p className="muted">Aufträge mit Fehlern / Prüfbedarf</p>{failed > 0 && <span className="badge err"><span aria-hidden="true">✕</span>Prüfen</span>}</div>}
</div>
</>)}
<Recent staff={me.kind === 'staff'} tickets={me.kind === 'customer' || can('tickets.read')} invoices={me.kind === 'customer' || can('invoices.read')} />
</>);
}

View file

@ -5,7 +5,7 @@ import { useSession } from '@/lib/session';
import { Alert, Field } from '@/components/ui';
interface Datev { beraterNr: number | null; mandantNr: number | null; skr: string | null; sachkontenlaenge: number; fiscalYearStart: string; erloeskonto19: number | null; erloeskonto7: number | null; erloeskonto0: number | null; diktatkuerzel: string | null; complete: boolean }
interface Settings { name: string | null; street: string | null; zip: string | null; city: string | null; country: string; taxNumber: string | null; vatId: string | null; bankName: string | null; iban: string | null; bic: string | null; invoicePrefix: string; defaultDueDays: number; paymentMethods: string[]; footerText: string | null; complete: boolean; datev: Datev }
interface Settings { name: string | null; street: string | null; zip: string | null; city: string | null; country: string; taxNumber: string | null; vatId: string | null; bankName: string | null; iban: string | null; bic: string | null; invoicePrefix: string; defaultDueDays: number; paymentMethods: string[]; footerText: string | null; complete: boolean; datev: Datev; autoBillingRuns?: boolean }
export default function Firma() {
const { can } = useSession(); const w = can('settings.write');
@ -23,6 +23,7 @@ export default function Firma() {
invoicePrefix: v('invoicePrefix'), defaultDueDays: Number(f.get('defaultDueDays') ?? 14),
paymentMethods: String(f.get('paymentMethods') ?? '').split(',').map((x) => x.trim()).filter(Boolean),
footerText: v('footerText') ?? null,
autoBillingRuns: f.get('autoBillingRuns') === 'on',
datevBeraterNr: n('datevBeraterNr'), datevMandantNr: n('datevMandantNr'), datevSkr: (v('datevSkr') as '03' | '04' | undefined) ?? null,
datevSachkontenlaenge: Number(f.get('datevSachkontenlaenge') ?? 4), datevFiscalYearStart: v('datevFiscalYearStart') ?? '01-01',
datevErloeskonto19: n('datevErloeskonto19'), datevErloeskonto7: n('datevErloeskonto7'), datevErloeskonto0: n('datevErloeskonto0'),
@ -60,6 +61,7 @@ export default function Firma() {
<Field id="paymentMethods" label="Zahlungsarten" hint="kommagetrennt"><input id="paymentMethods" name="paymentMethods" defaultValue={s.paymentMethods.join(', ')} disabled={!w} /></Field>
</div>
<Field id="footerText" label="Fußzeile auf der Rechnung (optional)" hint="z. B. Geschäftsführer, Registergericht"><input id="footerText" name="footerText" defaultValue={s.footerText ?? ''} disabled={!w} /></Field>
<label className="row" style={{ gap: 8, margin: '8px 0 16px' }}><input type="checkbox" name="autoBillingRuns" defaultChecked={!!s.autoBillingRuns} disabled={!w} style={{ width: 20, minHeight: 20 }} />Abrechnungslauf automatisch (alle 6 Stunden): fällige Vertragsperioden als Rechnungsentwürfe anlegen. Ausgestellt wird nie automatisch.</label>
<h3>DATEV-Export</h3>
<p className="muted small">Für den Buchungsstapel-Export unter Rechnungen → Export. Werte vom Steuerberater erfragen; ohne Beraternummer und Mandantennummer ist der DATEV-Export nicht möglich (das generische CSV/ZIP funktioniert unabhängig davon immer).</p>
{!s.datev.complete && <Alert kind="warn">DATEV-Stammdaten unvollständig: Beraternummer und Mandantennummer fehlen noch.</Alert>}

View file

@ -31,6 +31,7 @@ export default function Connectors() {
{msg && <Alert kind={msg.k}>{msg.t}</Alert>}
{open && type && <form className="card" onSubmit={create}><h2>Neue Verbindung</h2>
{sel === 'keyhelp' && <Alert kind="info"><strong>KeyHelp einrichten:</strong> Im KeyHelp-Adminbereich unter <em>Konfiguration → API</em> die API aktivieren und einen Schlüssel anlegen. Den Schlüssel <strong>auf die IP-Adresse dieses Servers beschränken</strong> (er hat Administratorrechte) und hier eintragen. Die KeyHelp-Version wird automatisch erkannt. Bei einem selbstsignierten Zertifikat den SHA-256-Fingerabdruck angeben (sicherer als die Prüfung abzuschalten). Der Abgleich arbeitet zunächst nur lesend.</Alert>}
{sel === 'plesk' && <Alert kind="info"><strong>Plesk einrichten:</strong> Auf dem Plesk-Server als root einen Secret Key erzeugen: <code>plesk bin secret_key -c -ip-address &lt;IP dieses Servers&gt; -description Kundencenter</code>. Der Schlüssel ist <strong>an diese IP gebunden</strong> und hat Administratorrechte. Adresse mit Port angeben (meist <code>:8443</code>); bei selbstsigniertem Zertifikat den Fingerabdruck eintragen. Für die Bereitstellung neuer Konten zusätzlich die gemeinsame IP-Adresse und eine Domain für neue Abonnements angeben. Abgleich, Kundenübernahme und Panel-Login funktionieren ohne diese beiden Angaben.</Alert>}
<div className="cols"><Field id="type" label="Typ"><select id="type" value={sel} onChange={(e) => setSel(e.target.value)}>{types.map((t) => <option key={t.key} value={t.key}>{t.name}</option>)}</select></Field>
<Field id="name" label="Name"><input id="name" name="name" required /></Field></div>
<ConfigFields fields={type.fields} prefix="f-" />

View file

@ -6,6 +6,15 @@ import { api } from '@/lib/api';
import { useSession } from '@/lib/session';
import { ROLE_LABEL } from '@/components/ui';
import { ThemeToggle } from '@/components/ThemeToggle';
import { Icon, type IconName } from '@/components/Icon';
import { Brand, SiteFooter } from '@/components/Brand';
import { TableCards } from '@/components/TableCards';
const ICONS: Record<string, IconName> = {
'/dashboard': 'home', '/lizenzen': 'key', '/ressourcen': 'server', '/vertraege': 'fileText', '/bestellungen': 'cart', '/rechnungen': 'receipt', '/tickets': 'ticket', '/admin/posteingang': 'inbox',
'/organisation': 'building', '/domains': 'globe', '/admin/kunden': 'users', '/admin/produkte': 'package', '/admin/domains': 'list', '/admin/benutzer': 'userCog', '/admin/auftraege': 'activity',
'/admin/audit': 'shield', '/einstellungen': 'settings', '/konto': 'user',
};
export default function AppLayout({ children }: { children: ReactNode }) {
const { me, loading, can, reload } = useSession(); const r = useRouter(); const path = usePathname(); const [open, setOpen] = useState(false);
@ -16,52 +25,55 @@ export default function AppLayout({ children }: { children: ReactNode }) {
useEffect(() => { if (enrollNeeded && path !== '/konto') r.replace('/konto'); }, [enrollNeeded, path, r]);
useEffect(() => setOpen(false), [path]);
if (loading || !me || me.pendingMfa) return <div className="center"><p className="muted" role="status">Wird geladen …</p></div>;
const link = (href: string, label: string) => <Link href={href} aria-current={path === href || path.startsWith(href + '/') ? 'page' : undefined}>{label}</Link>;
const link = (href: string, label: string) => <Link href={href} aria-current={path === href || path.startsWith(href + '/') ? 'page' : undefined}>{ICONS[href] && <Icon name={ICONS[href]} />}{label}</Link>;
const inGroup = (hrefs: string[]) => hrefs.some((h) => path === h || path.startsWith(h + '/'));
const group = (title: string, hrefs: string[], items: ReactNode) => (
<details className="group" open={inGroup(hrefs)}><summary>{title}</summary><div className="items">{items}</div></details>
<details className="group" open={inGroup(hrefs)}><summary>{title}<Icon name="chevron" className="icon chev" /></summary><div className="items">{items}</div></details>
);
async function logout() { await api('POST', '/auth/logout'); await reload(); r.replace('/login'); }
async function stopImpersonation() { const orgId = me!.impersonating!.orgId; await api('POST', '/auth/impersonate/stop'); await reload(); r.replace(`/admin/kunden/${orgId}`); }
const produkte = [(me.kind === 'customer' || can('licenses.read')) && ['/lizenzen', me.kind === 'customer' ? 'Meine Lizenzen' : 'Lizenzen'], (me.kind === 'customer' || can('resources.read')) && ['/ressourcen', 'Ressourcen'], (me.kind === 'customer' || can('contracts.read')) && ['/vertraege', 'Verträge'], (me.kind === 'customer' || can('orders.read')) && ['/bestellungen', 'Bestellungen']].filter(Boolean) as [string, string][];
const verwaltung = [can('customers.read') && ['/admin/kunden', 'Kunden'], can('products.read') && ['/admin/produkte', 'Produkte'], can('domains.read') && ['/admin/domains', 'Domain-Aufstellung'], can('users.read') && ['/admin/benutzer', 'Benutzer'], can('jobs.read') && ['/admin/auftraege', 'Aufträge'], can('audit.read') && ['/admin/audit', 'Audit-Protokoll'], (can('connectors.read') || can('backup.read')) && ['/einstellungen', 'Einstellungen']].filter(Boolean) as [string, string][];
const verwaltung = [can('customers.read') && ['/admin/kunden', 'Kunden'], can('products.read') && ['/admin/produkte', 'Produkte'], can('domains.read') && ['/admin/domains', 'Domain-Aufstellung'], can('users.read') && ['/admin/benutzer', 'Benutzer'], can('jobs.read') && ['/admin/auftraege', 'Aufträge'], can('audit.read') && ['/admin/audit', 'Audit-Protokoll'], can('status.read') && ['/admin/status', 'Statusseite'], (can('connectors.read') || can('backup.read')) && ['/einstellungen', 'Einstellungen']].filter(Boolean) as [string, string][];
const nav = (
<nav className={`nav ${open ? 'open' : ''}`} aria-label="Hauptnavigation">
<div className="brand">Kundencenter</div>
<Link href="/dashboard" className="brandlink" aria-label="Kundencenter – zur Übersicht"><Brand /></Link>
{!enrollNeeded && link('/dashboard', 'Übersicht')}
{!enrollNeeded && produkte.length > 0 && group('Produkte', produkte.map(([h]) => h), produkte.map(([h, l]) => <span key={h}>{link(h, l)}</span>))}
{!enrollNeeded && (me.kind === 'customer' || can('invoices.read')) && group('Abrechnung', ['/rechnungen'], link('/rechnungen', 'Rechnungen'))}
{!enrollNeeded && (me.kind === 'customer' || can('tickets.read')) && group('Support', ['/tickets', '/admin/posteingang'], <>{link('/tickets', 'Tickets')}{can('tickets.read') && <span>{link('/admin/posteingang', 'Posteingang')}</span>}</>)}
{!enrollNeeded && me.organizations.length > 0 && link('/organisation', 'Organisation')}
{!enrollNeeded && can('analytics.read') && link('/auswertung', 'Auswertung')}
{!enrollNeeded && link('/domains', 'Domain prüfen')}
{!enrollNeeded && me.kind === 'staff' && verwaltung.length > 0 && group('Verwaltung', verwaltung.map(([h]) => h), verwaltung.map(([h, l]) => <span key={h}>{link(h, l)}</span>))}
<div className="spacer" />
{link('/konto', 'Mein Konto')}
<div className="small who">
{me.kind === 'customer' && me.organizations[0] && <div className="org">{me.organizations[0].name}</div>}
{me.user.name}<br />{me.staffRole ? ROLE_LABEL[me.staffRole] : 'Kunde'}
<div className="who">
<span className="avatar" aria-hidden="true">{me.user.name.split(/\s+/).map((w) => w[0]).slice(0, 2).join('').toUpperCase()}</span>
<span className="small">
{me.kind === 'customer' && me.organizations[0] && <span className="org">{me.organizations[0].name}</span>}
<span className="name">{me.user.name}</span><span className="role">{me.staffRole ? ROLE_LABEL[me.staffRole] : 'Kunde'}</span>
</span>
</div>
<div className="row" style={{ padding: '0 8px' }}><ThemeToggle /></div>
<button className="btn small" onClick={logout}>Abmelden</button>
<div className="navactions"><ThemeToggle /><button className="btn small" onClick={logout}><Icon name="logout" /> Abmelden</button></div>
</nav>
);
const bottomLink = (href: string, label: string) => <Link href={href} aria-current={path === href || path.startsWith(href + '/') ? 'page' : undefined}>{label}</Link>;
const bottomLink = (href: string, label: string, icon: IconName) => <Link href={href} aria-current={path === href || path.startsWith(href + '/') ? 'page' : undefined}><Icon name={icon} className="ic" />{label}</Link>;
return (<>
{me.impersonating && (
<div role="status" style={{ position: 'sticky', top: 0, zIndex: 100, width: '100%', background: 'var(--warn)', color: '#1a1200', padding: '8px 16px', display: 'flex', flexWrap: 'wrap', gap: 8, alignItems: 'center', justifyContent: 'center', textAlign: 'center' }}>
<span>👁 Ansicht als Kunde: <strong>{me.impersonating.orgName}</strong> ({me.impersonating.customerNumber}) · Grund: {me.impersonating.reason}</span>
<div role="status" className="impersonate">
<span><Icon name="eye" /> Ansicht als Kunde: <strong>{me.impersonating.orgName}</strong> ({me.impersonating.customerNumber}) · Grund: {me.impersonating.reason}</span>
<button className="btn small" onClick={() => void stopImpersonation()}>Zurück zur Verwaltung</button>
</div>
)}
<div className="shell">
<div className="topbar"><strong>Kundencenter</strong><ThemeToggle compact /></div>
{nav}<main id="main" className="main">{trial && path !== '/einstellungen/lizenz' && <div className="alert warn" role="status" style={{ marginBottom: 16 }}>{trial} <Link href="/einstellungen/lizenz">Lizenz hinterlegen</Link></div>}{children}</main>
<div className="topbar"><Brand sub={false} /><ThemeToggle compact /></div>
{nav}<main id="main" className="main">{trial && path !== '/einstellungen/lizenz' && <div className="alert warn" role="status">{trial} <Link href="/einstellungen/lizenz">Lizenz hinterlegen</Link></div>}{children}<SiteFooter /><TableCards /></main>
{!enrollNeeded && <nav className="bottomnav" aria-label="Hauptnavigation (mobil)">
{bottomLink('/dashboard', 'Übersicht')}
{(me.kind === 'customer' || can('resources.read')) && bottomLink('/ressourcen', 'Ressourcen')}
{(me.kind === 'customer' || can('tickets.read')) && bottomLink('/tickets', 'Tickets')}
{(me.kind === 'customer' || can('invoices.read')) && bottomLink('/rechnungen', 'Rechnungen')}
<button type="button" aria-expanded={open} onClick={() => setOpen(!open)}>Mehr</button>
{bottomLink('/dashboard', 'Übersicht', 'home')}
{(me.kind === 'customer' || can('resources.read')) && bottomLink('/ressourcen', 'Ressourcen', 'server')}
{(me.kind === 'customer' || can('tickets.read')) && bottomLink('/tickets', 'Tickets', 'ticket')}
{(me.kind === 'customer' || can('invoices.read')) && bottomLink('/rechnungen', 'Rechnungen', 'receipt')}
<button type="button" aria-expanded={open} onClick={() => setOpen(!open)}><Icon name="menu" className="ic" />Mehr</button>
</nav>}
</div>
</>);

View file

@ -4,7 +4,7 @@ import Link from 'next/link';
import { useParams } from 'next/navigation';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Field, ResState, fmt } from '@/components/ui';
import { Alert, Field, ResState, fmt, fmtDate } from '@/components/ui';
import { SecretField } from '@/components/SecretField';
import { LicKind, type Lic } from '@/components/Licenses';
@ -68,7 +68,7 @@ export default function Lizenz() {
}
function extend(e: FormEvent<HTMLFormElement>) {
e.preventDefault(); const f = new FormData(e.currentTarget); const until = String(f.get('until') ?? ''); const preset = String(f.get('preset') ?? ''); const reason = String(f.get('reason') ?? '').trim() || undefined;
if (until) { const iso = new Date(`${until}T23:59:59`).toISOString(); ask('Verlängern', `Die Lizenz gilt dann bis ${fmt(iso)}.`, () => lifecycle({ action: 'extend', until: iso, reason })); return; }
if (until) { const iso = new Date(`${until}T23:59:59`).toISOString(); ask('Verlängern', `Die Lizenz gilt dann bis ${fmtDate(iso)}.`, () => lifecycle({ action: 'extend', until: iso, reason })); return; }
if (!preset) { setMsg({ k: 'warn', t: 'Bitte ein Datum oder eine Laufzeit wählen.' }); return; }
const [count, durationType] = preset.split(':');
ask('Verlängern', `Die Lizenz wird um ${count} ${DURATION[durationType!]}${Number(count) > 1 ? 'e' : ''} verlängert (ab dem späteren von heute und dem aktuellen Ablauf).`, () => lifecycle({ action: 'extend', durationType, count: Number(count), reason }));
@ -98,8 +98,8 @@ export default function Lizenz() {
<Dd label="Programm">{d.program ?? '–'}</Dd>
<Dd label="Produkt">{d.product ?? d.edition ?? '–'}</Dd>
<Dd label="Laufzeit">{d.durationType ? DURATION[d.durationType] ?? d.durationType : '–'}</Dd>
<Dd label="Gültig ab">{d.validFrom ? fmt(d.validFrom) : '–'}</Dd>
<Dd label="Gültig bis">{d.validUntil ? fmt(d.validUntil) : 'unbefristet'}</Dd>
<Dd label="Gültig ab">{d.validFrom ? fmtDate(d.validFrom) : '–'}</Dd>
<Dd label="Gültig bis">{d.validUntil ? fmtDate(d.validUntil) : 'unbefristet'}</Dd>
<Dd label="Letzte Prüfung durch das Programm">{d.lastCheckAt ? fmt(d.lastCheckAt) : 'noch nie'}</Dd>
<Dd label="Abrechnung">{d.contractId ? <Link href={`/vertraege/${d.contractId}`}>Vertrag {d.contractNumber}</Link> : 'ohne Berechnung'}</Dd>
{d.parent && <Dd label="Basislizenz"><Link href={`/lizenzen/${d.parent.id}`}>{d.parent.program}{d.parent.product ? ` · ${d.parent.product}` : ''}</Link></Dd>}
@ -166,7 +166,7 @@ export default function Lizenz() {
</>}
{(!d.addon && (d.addons.length > 0 || d.can.manage)) && <div className="card"><div className="row between"><h2>Add-ons</h2>{d.can.manage && d.orgId && <Link className="btn small" href={`/lizenzen/neu?org=${d.orgId}&parent=${d.id}`}>Add-on vergeben</Link>}</div>
{d.addons.length === 0 ? <p className="muted">Keine Add-ons.</p> : <ul>{d.addons.map((x) => <li key={x.id}><Link href={`/lizenzen/${x.id}`}>{x.product ?? x.name}</Link> <ResState value={x.state} /> <span className="small muted">bis {x.validUntil ? fmt(x.validUntil) : 'unbefristet'}</span></li>)}</ul>}
{d.addons.length === 0 ? <p className="muted">Keine Add-ons.</p> : <ul>{d.addons.map((x) => <li key={x.id}><Link href={`/lizenzen/${x.id}`}>{x.product ?? x.name}</Link> <ResState value={x.state} /> <span className="small muted">bis {x.validUntil ? fmtDate(x.validUntil) : 'unbefristet'}</span></li>)}</ul>}
</div>}
{staff && d.history.length > 0 && <div className="card"><h2>Verlauf</h2><div className="tablewrap"><table><thead><tr><th>Zeitpunkt</th><th>Vorgang</th><th>Durch</th><th>Ergebnis</th></tr></thead><tbody>

View file

@ -3,7 +3,7 @@ import { useCallback, useEffect, useState } from 'react';
import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Empty, ResState, fmt } from '@/components/ui';
import { Alert, Empty, ResState, fmt, fmtDate } from '@/components/ui';
import { SecretField } from '@/components/SecretField';
import { LicKind, type Lic } from '@/components/Licenses';
@ -49,7 +49,7 @@ export default function Lizenzen() {
<td><Link href={`/lizenzen/${l.id}`}>{l.program ?? l.name}{l.product ? ` · ${l.product}` : ''}</Link><LicKind l={l} /><div className="mono small muted">{l.keyMasked}</div></td>
<td>{l.orgId ? <Link href={`/admin/kunden/${l.orgId}`}>{l.customerNumber} · {l.orgName}</Link> : <span className="badge warn"><span aria-hidden="true">▲</span>Nicht zugewiesen</span>}</td>
<td><ResState value={l.state} /></td>
<td>{l.validUntil ? <>{fmt(l.validUntil)}{soon(l.validUntil) && l.state === 'active' && <> <span className="badge warn"><span aria-hidden="true">▲</span>bald</span></>}</> : 'unbefristet'}</td>
<td>{l.validUntil ? <>{fmtDate(l.validUntil)}{soon(l.validUntil) && l.state === 'active' && <> <span className="badge warn"><span aria-hidden="true">▲</span>bald</span></>}</> : 'unbefristet'}</td>
<td>{devices(l)}</td>
<td>{l.contractId ? <Link href={`/vertraege/${l.contractId}`}>{l.contractNumber}</Link> : <span className="muted small">ohne Berechnung</span>}</td>
</tr>)}</tbody></table></div></div>
@ -58,7 +58,7 @@ export default function Lizenzen() {
<div className="productcard" key={l.id}>
<div className="row between"><h3><Link href={`/lizenzen/${l.id}`}>{l.program ?? l.name}</Link></h3><ResState value={l.state} /></div>
<div className="id">{l.product ?? l.edition}<LicKind l={l} /></div>
<div className="small muted">Gültig bis: {l.validUntil ? fmt(l.validUntil) : 'unbefristet'}</div>
<div className="small muted">Gültig bis: {l.validUntil ? fmtDate(l.validUntil) : 'unbefristet'}</div>
<div className="small muted">Geräte: {devices(l)}</div>
<div style={{ marginTop: 4 }}><SecretField resourceId={l.id} compact /></div>
<div style={{ marginTop: 8 }}><Link className="btn small" href={`/lizenzen/${l.id}`}>Details und Geräte</Link></div>

View file

@ -4,10 +4,10 @@ import { useParams, useSearchParams } from 'next/navigation';
import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Field, InvoiceStatusBadge, eur, fmt } from '@/components/ui';
import { Alert, Field, InvoiceStatusBadge, eur, fmt, fmtDay } from '@/components/ui';
interface Item { id: string; description: string; quantity: number; unitPriceNetCents: number; taxBp: number; discountBp: number; netCents: number; taxCents: number; grossCents: number }
interface Inv { id: string; number: string | null; orgId: string; orgName: string; status: string; overdue: boolean; issueDate: string | null; dueDate: string | null; paymentMethod: string | null; note: string | null; totalNetCents: number; totalTaxCents: number; totalGrossCents: number; cancelsInvoiceId: string | null; cancelledByInvoiceId: string | null; items: Item[]; canWrite: boolean }
interface Inv { id: string; number: string | null; orgId: string; orgName: string; status: string; overdue: boolean; issueDate: string | null; dueDate: string | null; paymentMethod: string | null; note: string | null; totalNetCents: number; totalTaxCents: number; totalGrossCents: number; cancelsInvoiceId: string | null; cancelledByInvoiceId: string | null; items: Item[]; canWrite: boolean; billingPeriods?: { contractId: string; start: string; end: string }[] }
type Row = { description: string; quantity: string; unitPrice: string; taxBp: string; discount: string };
const emptyRow = (): Row => ({ description: '', quantity: '1', unitPrice: '', taxBp: '19', discount: '0' });
interface Suggested { description: string; quantity: number; unitPriceNetCents: number; taxBp: number; discountBp?: number }
@ -51,7 +51,7 @@ export default function RechnungDetail() {
const isDraft = inv.status === 'draft';
return (<>
<div className="row between"><h1>{inv.number ?? 'Entwurf'} {inv.orgName && <span className="muted">· {inv.orgName}</span>}</h1><Link className="btn" href="/rechnungen">← Rechnungen</Link></div>
<p className="muted small"><InvoiceStatusBadge value={inv.status} overdue={inv.overdue} />{inv.issueDate && <> · ausgestellt {fmt(inv.issueDate)}</>}{inv.dueDate && <> · fällig {fmt(inv.dueDate)}</>}{inv.paymentMethod && <> · {inv.paymentMethod}</>}</p>
<p className="muted small"><InvoiceStatusBadge value={inv.status} overdue={inv.overdue} />{inv.issueDate && <> · ausgestellt {fmtDay(inv.issueDate)}</>}{inv.dueDate && <> · fällig {fmtDay(inv.dueDate)}</>}{inv.paymentMethod && <> · {inv.paymentMethod}</>}</p>
{inv.cancelsInvoiceId && <Alert kind="info">Dies ist eine Stornorechnung zu <Link href={`/rechnungen/${inv.cancelsInvoiceId}`}>einer anderen Rechnung</Link>.</Alert>}
{inv.cancelledByInvoiceId && <Alert kind="warn">Diese Rechnung wurde storniert. Storno: <Link href={`/rechnungen/${inv.cancelledByInvoiceId}`}>ansehen</Link></Alert>}
{err && <Alert kind="err">{err}</Alert>}{ok && <Alert kind="ok">{ok}</Alert>}
@ -95,6 +95,7 @@ export default function RechnungDetail() {
{!isDraft && <div className="row" style={{ marginTop: 16 }}>
<a className="btn" href={`/api/invoices/${id}/pdf`} target="_blank" rel="noreferrer">PDF ansehen</a>
{inv.canWrite && inv.status === 'open' && <button className="btn" disabled={busy} onClick={() => run(() => api('POST', `/invoices/${id}/mark-paid`), 'Als bezahlt markiert.')}>Als bezahlt markieren</button>}
{inv.canWrite && inv.status === 'cancelled' && (inv.billingPeriods?.length ?? 0) > 0 && <button className="btn" disabled={busy} onClick={() => { if (confirm('Die Vertragsperioden dieser stornierten Rechnung erneut abrechnen? Der nächste Abrechnungslauf legt dafür einen neuen Entwurf an.')) run(() => api('POST', `/invoices/${id}/release-periods`), 'Perioden freigegeben – der nächste Abrechnungslauf rechnet sie neu ab.'); }}>Perioden erneut abrechnen</button>}
{inv.canWrite && inv.status === 'open' && <button className="btn" disabled={busy} onClick={() => { const reason = prompt('Grund für den Storno (optional):') ?? undefined; run(() => api('POST', `/invoices/${id}/cancel`, reason ? { reason } : {}), 'Storniert.'); }}>Stornieren</button>}
</div>}
{inv.note && <p className="muted small" style={{ marginTop: 16 }}>Notiz: {inv.note}</p>}

View file

@ -3,16 +3,39 @@ import { useEffect, useState } from 'react';
import Link from 'next/link';
import { useRouter } from 'next/navigation';
import { api, errMsg } from '@/lib/api';
import { Alert, Empty, eur, fmt } from '@/components/ui';
import { Alert, Empty, eur, fmt, fmtDay } from '@/components/ui';
interface OverdueInv { id: string; number: string | null; orgName: string; customerNumber: string; dueDate: string | null; totalGrossCents: number }
interface DueContract { id: string; number: string; orgId: string; orgName: string; customerNumber: string; productName: string | null; lastInvoicedAt: string | null; dueSince: string; lastGrossCents: number | null }
interface Data { overdueInvoices: OverdueInv[]; dueContracts: DueContract[] }
interface Period { contractId: string; contractNumber: string; orgId: string; start: string; end: string; description: string; unitPriceNetCents: number; taxBp: number }
/** Abrechnungslauf (#50): fällige Vertragsperioden als Entwürfe anlegen – jede Periode genau einmal, nichts wird ausgestellt. */
function BillingRun({ onDone }: { onDone: () => void }) {
const [p, setP] = useState<{ periods: Period[]; auto: boolean } | null>(null); const [msg, setMsg] = useState<{ k: 'ok' | 'err'; t: string } | null>(null); const [busy, setBusy] = useState(false);
const load = () => api<{ periods: Period[]; auto: boolean }>('GET', '/invoices/billing-run/preview').then(setP).catch((e) => setMsg({ k: 'err', t: errMsg(e) }));
useEffect(() => { void load(); }, []);
async function go() {
setBusy(true); setMsg(null);
try { const r = await api<{ drafts: { items: number }[] }>('POST', '/invoices/billing-run'); setMsg({ k: 'ok', t: r.drafts.length ? `${r.drafts.length} Entwürfe mit ${r.drafts.reduce((n, d) => n + d.items, 0)} Positionen angelegt. Bitte unter Rechnungen prüfen und ausstellen.` : 'Nichts abzurechnen.' }); await load(); onDone(); }
catch (x) { setMsg({ k: 'err', t: errMsg(x) }); } finally { setBusy(false); }
}
return (<div className="card">
<div className="row between"><h2>Abrechnungslauf</h2><button className="btn primary" disabled={busy || !p || p.periods.length === 0} onClick={go}>{busy ? 'Bitte warten …' : 'Entwürfe anlegen'}</button></div>
<p className="muted small">Fällige Vertragsperioden nach dem Abrechnungsintervall des Vertrags (monatlich/jährlich, im Voraus). Je Kunde ein Entwurf; jede Periode wird genau einmal abgerechnet. Automatischer Lauf: {p?.auto ? 'eingeschaltet' : 'aus'} (Einstellungen → Firma).</p>
{msg && <Alert kind={msg.k}>{msg.t}</Alert>}
{p === null ? <p className="muted" role="status">Wird geladen …</p> : p.periods.length === 0 ? <Empty title="Keine fälligen Perioden" /> :
<div className="tablewrap"><table><thead><tr><th>Vertrag</th><th>Zeitraum</th><th>Position</th><th>Netto</th></tr></thead><tbody>
{p.periods.map((x) => (<tr key={`${x.contractId}:${x.start}`}><td className="mono">{x.contractNumber}</td><td className="small">{fmtDay(x.start)} – {fmtDay(x.end)}</td><td className="small">{x.description}</td><td>{eur(x.unitPriceNetCents)}</td></tr>))}
</tbody></table></div>}
</div>);
}
export default function Faellig() {
const r = useRouter();
const [d, setD] = useState<Data | null>(null); const [err, setErr] = useState(''); const [busy, setBusy] = useState('');
useEffect(() => { api<Data>('GET', '/invoices/reminders').then(setD).catch((e) => setErr(errMsg(e))); }, []);
const reload = () => api<Data>('GET', '/invoices/reminders').then(setD).catch((e) => setErr(errMsg(e)));
useEffect(() => { void reload(); }, []);
async function createFor(c: DueContract) {
setErr(''); setBusy(c.id);
try { const inv = await api<{ id: string }>('POST', '/invoices', { orgId: c.orgId }); r.push(`/rechnungen/${inv.id}?fromContract=${c.id}`); }
@ -22,13 +45,14 @@ export default function Faellig() {
<div className="row between"><h1>Fällig</h1><Link className="btn" href="/rechnungen">← Rechnungen</Link></div>
<p className="muted">Überfällige, bereits ausgestellte Rechnungen und aktive Verträge, bei denen die letzte Rechnung länger zurückliegt als ihre Verlängerungslaufzeit.</p>
{err && <Alert kind="err">{err}</Alert>}
<BillingRun onDone={() => void reload()} />
{d === null ? <p className="muted" role="status">Wird geladen …</p> : (<>
<div className="card">
<h2>Überfällige Rechnungen ({d.overdueInvoices.length})</h2>
{d.overdueInvoices.length === 0 ? <Empty title="Keine überfälligen Rechnungen" /> :
<div className="tablewrap"><table><thead><tr><th>Nr.</th><th>Kunde</th><th>Fällig seit</th><th>Betrag</th></tr></thead><tbody>
{d.overdueInvoices.map((i) => (<tr key={i.id}><td className="mono"><Link href={`/rechnungen/${i.id}`}>{i.number}</Link></td><td>{i.orgName} <span className="muted small">({i.customerNumber})</span></td>
<td><span className="badge err"><span aria-hidden="true">▲</span>{i.dueDate ? fmt(i.dueDate) : '–'}</span></td><td>{eur(i.totalGrossCents)}</td></tr>))}
<td><span className="badge err"><span aria-hidden="true">▲</span>{i.dueDate ? fmtDay(i.dueDate) : '–'}</span></td><td>{eur(i.totalGrossCents)}</td></tr>))}
</tbody></table></div>}
</div>
<div className="card">

View file

@ -4,7 +4,7 @@ import Link from 'next/link';
import { useParams } from 'next/navigation';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { ACTION_LABEL, Alert, Field, JobStatus, ResState, fmt, eur, CUSTOMER_ACTIONS } from '@/components/ui';
import { ACTION_LABEL, Alert, Field, JobStatus, ResState, fmt, eur, CUSTOMER_ACTIONS, fmtDate } from '@/components/ui';
import { SecretField } from '@/components/SecretField';
import { uuid } from '@/lib/uuid';
import { HostingPanel, UsageBars } from '@/components/HostingPanel';
@ -64,8 +64,8 @@ export default function Ressource() {
{d.missing && <Alert kind="warn">Diese Ressource wurde beim letzten Abgleich nicht mehr beim Anbieter gefunden.</Alert>}
<div className="card"><h2>Details</h2>
<dl className="cols" style={{ margin: 0 }}>
<div><dt className="muted small">Gültig ab</dt><dd style={{ margin: 0 }}>{d.validFrom ? fmt(d.validFrom) : '–'}</dd></div>
<div><dt className="muted small">Gültig bis</dt><dd style={{ margin: 0 }}>{d.validUntil ? fmt(d.validUntil) : 'unbefristet'}</dd></div>
<div><dt className="muted small">Gültig ab</dt><dd style={{ margin: 0 }}>{d.validFrom ? fmtDate(d.validFrom) : '–'}</dd></div>
<div><dt className="muted small">Gültig bis</dt><dd style={{ margin: 0 }}>{d.validUntil ? fmtDate(d.validUntil) : 'unbefristet'}</dd></div>
{d.type !== 'hosting_account' && Object.entries(d.limits).map(([k, v]) => <div key={k}><dt className="muted small">{LIMIT_LABEL[k] ?? k}</dt><dd style={{ margin: 0 }}>{v === null ? 'unbegrenzt' : String(v)}{d.usage[k] !== undefined ? ` (genutzt: ${String(d.usage[k])})` : ''}</dd></div>)}
{d.details.edition && <div><dt className="muted small">Edition</dt><dd style={{ margin: 0 }}>{String(d.details.edition)}</dd></div>}
{d.details.program && <div><dt className="muted small">Programm</dt><dd style={{ margin: 0 }}>{String(d.details.program)}</dd></div>}

View file

@ -3,7 +3,7 @@ import { useEffect, useState, type FormEvent } from 'react';
import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Empty, Field, ResState, fmt } from '@/components/ui';
import { Alert, Empty, Field, ResState, fmt, fmtDate } from '@/components/ui';
import { SecretField } from '@/components/SecretField';
interface R { id: string; type: string; name: string; state: string; validUntil: string | null; syncedAt: string; stale: boolean; staleReason: string | null; orgId: string | null; instance?: string; canReveal?: boolean }
@ -58,13 +58,13 @@ export default function Ressourcen() {
{staff ? (
<div className="card"><div className="tablewrap"><table><thead><tr><th>Name</th>{!lic && <th>Typ</th>}<th>Status</th><th>Gültig bis</th><th>Stand</th>{lic && <th>Lizenzschlüssel</th>}</tr></thead><tbody>
{rows.map((r) => <tr key={r.id}><td><Link href={`/ressourcen/${r.id}`}>{r.name}</Link>{!r.orgId && <> <span className="badge warn"><span aria-hidden="true">▲</span>Nicht zugewiesen</span></>}{canAssign && !r.orgId && <div style={{ marginTop: 8 }}><AssignCell r={r} custs={custs} onError={setErr} onCreated={(c, cr) => { setCusts((l) => [...l, c]); setErr(''); setOk(`Kunde ${cr.customerNumber} angelegt. ` + (cr.mail === 'sent' ? 'Die Einladung wurde per E-Mail versendet.' : cr.inviteLink ? `E-Mail-Versand ist nicht eingerichtet. Einladungslink (nur jetzt sichtbar): ${cr.inviteLink}` : '') + ' Jetzt noch „Zuweisen“ klicken.'); }} onDone={() => { setErr(''); setOk(`„${r.name}“ wurde zugewiesen. Kunden dürfen daran zunächst keine Aktionen ausführen (im Produkt bzw. an der Ressource freigebbar).`); void reload(); }} /></div>}</td>{!lic && <td>{TYPE[r.type] ?? r.type}</td>}<td><ResState value={r.state} /></td>
<td>{r.validUntil ? fmt(r.validUntil) : 'unbefristet'}</td><td className="small">{fmt(r.syncedAt)}{r.stale && <> <span className="badge warn"><span aria-hidden="true">▲</span>Veraltet</span></>}</td>{lic && <td>{r.canReveal ? <SecretField resourceId={r.id} compact /> : <span className="muted small">–</span>}</td>}</tr>)}</tbody></table></div></div>
<td>{r.validUntil ? fmtDate(r.validUntil) : 'unbefristet'}</td><td className="small">{fmt(r.syncedAt)}{r.stale && <> <span className="badge warn"><span aria-hidden="true">▲</span>Veraltet</span></>}</td>{lic && <td>{r.canReveal ? <SecretField resourceId={r.id} compact /> : <span className="muted small">–</span>}</td>}</tr>)}</tbody></table></div></div>
) : (
<div className="productgrid">{rows.map((r) => (
<div className="productcard" key={r.id}>
<div className="row between"><h3><Link href={`/ressourcen/${r.id}`}>{r.name}</Link></h3><ResState value={r.state} /></div>
{!lic && <div className="id">{TYPE[r.type] ?? r.type}</div>}
<div className="small muted">Gültig bis: {r.validUntil ? fmt(r.validUntil) : 'unbefristet'}</div>
<div className="small muted">Gültig bis: {r.validUntil ? fmtDate(r.validUntil) : 'unbefristet'}</div>
<div className="small muted">Stand: {fmt(r.syncedAt)}{r.stale && <> <span className="badge warn"><span aria-hidden="true">▲</span>Veraltet</span></>}</div>
{lic && r.canReveal && <div style={{ marginTop: 4 }}><SecretField resourceId={r.id} compact /></div>}
<div style={{ marginTop: 8 }}><Link className="btn small" href={`/ressourcen/${r.id}`}>Details ansehen</Link></div>

View file

@ -5,6 +5,7 @@ import Link from 'next/link';
import { api, apiUpload, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Field, TicketStatusBadge, TICKET_PRIORITY, fmt } from '@/components/ui';
import { Icon } from '@/components/Icon';
const MAX_FILES = 5;
const ALLOWED = 'image/png,image/jpeg,image/gif,image/webp,application/pdf';
@ -14,8 +15,8 @@ function AttachmentList({ ticketId, atts }: { ticketId: string; atts: Attachment
return (<div className="row" style={{ marginTop: 8, flexWrap: 'wrap', gap: 8 }}>
{atts.map((a) => { const href = `/api/tickets/${ticketId}/attachments/${a.id}`; const kb = Math.max(1, Math.round(a.sizeBytes / 1024));
return a.contentType.startsWith('image/')
? <a key={a.id} href={href} target="_blank" rel="noreferrer" title={`${a.filename} (${kb} KB)`}><img src={href} alt={a.filename} style={{ maxWidth: 160, maxHeight: 120, borderRadius: 6, border: '1px solid var(--border)', display: 'block' }} /></a>
: <a key={a.id} className="btn small" href={href} target="_blank" rel="noreferrer">📄 {a.filename} <span className="muted small">({kb} KB)</span></a>; })}
? <a key={a.id} href={href} target="_blank" rel="noreferrer" title={`${a.filename} (${kb} KB)`}><img src={href} alt={a.filename} loading="lazy" decoding="async" style={{ maxWidth: 160, maxHeight: 120, borderRadius: 6, border: '1px solid var(--border)', display: 'block' }} /></a>
: <a key={a.id} className="btn small" href={href} target="_blank" rel="noreferrer"><Icon name="file" /> {a.filename} <span className="muted small">({kb} KB)</span></a>; })}
</div>);
}
interface Msg { id: string; authorId: string; authorName: string; authorKind: 'customer' | 'staff'; body: string; internalNote: boolean; createdAt: string; attachments: Attachment[] }

View file

@ -4,7 +4,7 @@ import Link from 'next/link';
import { useParams } from 'next/navigation';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, ContractStatusBadge, Field, fmt, INTERVAL, type Price, PriceText } from '@/components/ui';
import { Alert, ContractStatusBadge, Field, fmt, INTERVAL, type Price, PriceText, fmtDate } from '@/components/ui';
interface D { id: string; number: string; orgName: string; status: string; productName: string; startedAt: string | null; termEnd: string | null; renewal: string; renewalTermMonths: number; noticeDays: number; cancelRequestedAt: string | null; cancelEffectiveAt: string | null; cancelledAt: string | null; resourceId: string | null; canCancel: boolean; canEdit?: boolean;
price: Price & { customerType: string; name: string; sku: string; version: number; terms: { termMonths: number }; basis: 'net' | 'gross'; unitRecurringCents: number; unitSetupCents: number; adjusted?: { at: string; reason: string } } }
@ -16,7 +16,7 @@ export default function Vertrag() {
const load = useCallback(() => api<D>('GET', `/contracts/${id}`).then(setD).catch((e) => setMsg({ k: 'err', t: errMsg(e) })), [id]);
useEffect(() => { void load(); }, [load]);
if (!d) return msg ? <Alert kind={msg.k}>{msg.t}</Alert> : <p className="muted" role="status">Wird geladen …</p>;
async function cancel(immediate: boolean) { try { const r = await api<{ cancelEffectiveAt: string }>('POST', `/contracts/${id}/cancel`, { immediate }); setConfirm(null); setMsg({ k: 'ok', t: `Die Kündigung wurde vorgemerkt und wird wirksam am ${fmt(r.cancelEffectiveAt)}.` }); void load(); } catch (x) { setMsg({ k: 'err', t: errMsg(x) }); } }
async function cancel(immediate: boolean) { try { const r = await api<{ cancelEffectiveAt: string }>('POST', `/contracts/${id}/cancel`, { immediate }); setConfirm(null); setMsg({ k: 'ok', t: `Die Kündigung wurde vorgemerkt und wird wirksam am ${fmtDate(r.cancelEffectiveAt)}.` }); void load(); } catch (x) { setMsg({ k: 'err', t: errMsg(x) }); } }
async function revoke() { try { await api('POST', `/contracts/${id}/cancel/revoke`); setMsg({ k: 'ok', t: 'Die Kündigung wurde zurückgenommen.' }); void load(); } catch (x) { setMsg({ k: 'err', t: errMsg(x) }); } }
async function save(e: FormEvent<HTMLFormElement>) {
e.preventDefault(); const f = new FormData(e.currentTarget); const g = (k: string) => String(f.get(k) ?? '');
@ -34,12 +34,12 @@ export default function Vertrag() {
<p><Link href="/vertraege">← Alle Verträge</Link></p>
<div className="row between"><h1>{d.productName}</h1><ContractStatusBadge value={d.status} /></div><p className="muted"><span className="mono">{d.number}</span> · {d.orgName}</p>
{msg && <Alert kind={msg.k}>{msg.t}</Alert>}
{pending && <Alert kind="warn">Dieser Vertrag ist gekündigt und endet am <strong>{fmt(d.cancelEffectiveAt!)}</strong>.</Alert>}
{pending && <Alert kind="warn">Dieser Vertrag ist gekündigt und endet am <strong>{fmtDate(d.cancelEffectiveAt!)}</strong>.</Alert>}
<div className="card"><h2>Konditionen</h2>
<dl className="cols" style={{ margin: 0 }}>
<div><dt className="muted small">Preis</dt><dd style={{ margin: 0 }}><PriceText p={d.price} priv={priv} /></dd></div>
<div><dt className="muted small">Beginn</dt><dd style={{ margin: 0 }}>{d.startedAt ? fmt(d.startedAt) : '–'}</dd></div>
<div><dt className="muted small">Laufzeit bis</dt><dd style={{ margin: 0 }}>{d.termEnd ? fmt(d.termEnd) : 'unbefristet'}</dd></div>
<div><dt className="muted small">Laufzeit bis</dt><dd style={{ margin: 0 }}>{d.termEnd ? fmtDate(d.termEnd) : 'unbefristet'}</dd></div>
<div><dt className="muted small">Verlängerung</dt><dd style={{ margin: 0 }}>{d.renewal === 'auto' ? `automatisch um ${d.renewalTermMonths} Monat(e)` : 'keine'}</dd></div>
<div><dt className="muted small">Kündigungsfrist</dt><dd style={{ margin: 0 }}>{d.noticeDays} Tage</dd></div>
<div><dt className="muted small">Abrechnung</dt><dd style={{ margin: 0 }}>{INTERVAL[d.price.interval]}</dd></div></dl>

View file

@ -3,7 +3,7 @@ import { useEffect, useState } from 'react';
import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, ContractStatusBadge, Empty, Field, fmt, type Price, PriceText } from '@/components/ui';
import { Alert, ContractStatusBadge, Empty, Field, fmt, type Price, PriceText, fmtDate } from '@/components/ui';
interface C { id: string; number: string; orgName: string; status: string; productName: string; termEnd: string | null; cancelEffectiveAt: string | null; price: Price & { customerType: string } }
export default function Vertraege() {
@ -16,6 +16,6 @@ export default function Vertraege() {
{list === null ? <p className="muted" role="status">Wird geladen …</p> : list.length === 0 ? <Empty title="Keine Verträge">Verträge entstehen aus Bestellungen.</Empty> :
<div className="tablewrap"><table><thead><tr><th>Nr.</th><th>Produkt</th>{staff && <th>Kunde</th>}<th>Preis</th><th>Laufzeit bis</th><th>Status</th></tr></thead><tbody>
{list.map((c) => <tr key={c.id}><td className="mono"><Link href={`/vertraege/${c.id}`}>{c.number}</Link></td><td>{c.productName}</td>{staff && <td>{c.orgName}</td>}<td className="small"><PriceText p={c.price} priv={c.price.customerType === 'private'} /></td>
<td>{c.termEnd ? fmt(c.termEnd) : 'unbefristet'}{c.cancelEffectiveAt && <div className="small"><span className="badge warn"><span aria-hidden="true">▲</span>Gekündigt zum {fmt(c.cancelEffectiveAt)}</span></div>}</td><td><ContractStatusBadge value={c.status} /></td></tr>)}</tbody></table></div>}
<td>{c.termEnd ? fmtDate(c.termEnd) : 'unbefristet'}{c.cancelEffectiveAt && <div className="small"><span className="badge warn"><span aria-hidden="true">▲</span>Gekündigt zum {fmtDate(c.cancelEffectiveAt)}</span></div>}</td><td><ContractStatusBadge value={c.status} /></td></tr>)}</tbody></table></div>}
</div></>);
}

Binary file not shown.

After

Width:  |  Height:  |  Size: 9 KiB

View file

@ -0,0 +1,23 @@
'use client';
import { Suspense, useEffect, useState } from 'react';
import Link from 'next/link';
import { useSearchParams } from 'next/navigation';
import { api, errMsg } from '@/lib/api';
import { Alert } from '@/components/ui';
function Bestaetigen() {
const token = useSearchParams().get('token') ?? '';
const [state, setState] = useState<{ k: 'ok' | 'err' | 'info'; t: string } | null>(null);
useEffect(() => {
if (!token) { setState({ k: 'err', t: 'Der Link ist unvollständig.' }); return; }
api<{ status: 'active' | 'pending_approval' }>('POST', '/auth/verify-email', { token })
.then((r) => setState(r.status === 'active' ? { k: 'ok', t: 'Danke! Ihre E-Mail-Adresse ist bestätigt. Sie können sich jetzt anmelden.' } : { k: 'info', t: 'Danke! Ihre E-Mail-Adresse ist bestätigt. Wir prüfen Ihre Registrierung und schalten Ihren Zugang zeitnah frei – Sie erhalten dann eine E-Mail.' }))
.catch((x) => setState({ k: 'err', t: errMsg(x) }));
}, [token]);
return <>{state ? <Alert kind={state.k}>{state.t}</Alert> : <p className="muted" role="status">Wird bestätigt …</p>}</>;
}
export default function EmailBestaetigen() {
return <main id="main" className="center"><div className="auth card"><h1>E-Mail bestätigen</h1>
<Suspense fallback={<p className="muted" role="status">Wird geladen …</p>}><Bestaetigen /></Suspense>
<p className="small" style={{ marginTop: 16 }}><Link href="/login">Zur Anmeldung</Link></p></div></main>;
}

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.9 KiB

View file

@ -1,82 +1,142 @@
/* Designsystem v3 "KeyControl": dunkles Navy als vertrauenswürdige, dauerhaft sichtbare Seitenleiste,
klares Blau als Primärfarbe, helle Arbeitsfläche mit klar getrennten Bereichen. Hell/Dunkel automatisch
über prefers-color-scheme, zusätzlich manuell über [data-theme] umschaltbar (siehe ThemeToggle). */
/* Designsystem v4 „FlessingLabs“: angelehnt an flessinglabs.com – Schrift Geist, Markenverlauf Cyan → Blau → Violett,
fast schwarze Flächen mit hauchdünnen Rändern. Die Seitenleiste ist immer im FlessingLabs-Dunkel; die Arbeitsfläche
folgt prefers-color-scheme oder der manuellen Wahl über [data-theme] (siehe ThemeToggle).
Primärbuttons nutzen eine abgedunkelte Variante des Markenverlaufs, damit weißer Text überall >= 4,5:1 erreicht. */
:root {
--bg: #f4f6fa; --surface: #ffffff; --surface-2: #eef1f6; --border: #e3e8f0; --text: #172033; --muted: #5b6472;
--accent: #3b6fd8; --accent2: #14b8a6; --accent-contrast: #ffffff; --focus: #3b6fd8;
--ok: #22a06b; --ok-bg: #e4f5ec; --info: #2e6fe0; --info-bg: #e7f1fc; --warn: #e59a17; --warn-bg: #fdf1dc; --err: #dc4c64; --err-bg: #fbe7ea; --lock: #4b5563; --lock-bg: #eceef2;
--nav-bg: #173568; --nav-text: #dbe4f7; --nav-muted: #8fa4d4; --nav-border: #24417f; --nav-hover: #1f4084; --nav-active-bg: #2a4d93; --nav-active-text: #ffffff;
--shadow-sm: 0 1px 2px rgba(23, 32, 51, .04), 0 1px 1px rgba(23, 32, 51, .04);
--shadow-md: 0 8px 20px rgba(23, 32, 51, .06), 0 2px 6px rgba(23, 32, 51, .04);
--radius: 12px; --radius-sm: 8px; --s1: 4px; --s2: 8px; --s3: 16px; --s4: 24px; --s5: 40px;
--font: var(--font-inter), system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif;
--bg: #f5f7fb; --surface: #ffffff; --surface-2: #eef1f7; --border: #e3e7ef; --text: #111522; --muted: #5b6475;
--accent: #1a5fd0; --accent2: #0a7ea8; --accent-contrast: #ffffff; --focus: #1a5fd0; --border-strong: #7a8599;
--ok: #17784c; --ok-bg: #e4f5ec; --info: #2257c4; --info-bg: #e7f1fc; --warn: #8a5300; --warn-bg: #fdf1dc; --err: #b52f47; --err-bg: #fbe7ea; --lock: #4b5563; --lock-bg: #eceef2;
--nav-bg: #0b0d14; --nav-text: #c9d1e0; --nav-muted: #7b8599; --nav-border: rgba(255, 255, 255, .08); --nav-hover: #121622; --nav-active-bg: #171c2b; --nav-active-text: #ffffff;
--shadow-sm: 0 1px 2px rgba(17, 21, 34, .05);
--shadow-md: 0 10px 28px rgba(17, 21, 34, .08), 0 2px 6px rgba(17, 21, 34, .04);
--glow: rgba(37, 132, 255, .12);
--brand-gradient: linear-gradient(135deg, #20d4f5 0%, #2584ff 48%, #7028ff 100%);
--brand-btn: linear-gradient(135deg, #0a7ea8 0%, #1a66e0 48%, #6a24f0 100%);
--radius: 12px; --radius-lg: 16px; --radius-sm: 10px; --s1: 4px; --s2: 8px; --s3: 16px; --s4: 24px; --s5: 40px;
--font: var(--font-geist), system-ui, -apple-system, 'Segoe UI', Roboto, sans-serif;
--font-mono: var(--font-geist-mono), ui-monospace, SFMono-Regular, Menlo, monospace;
}
@media (prefers-color-scheme: dark) { :root:not([data-theme='light']) {
--bg: #0d1117; --surface: #161b22; --surface-2: #1c2129; --border: #262c36; --text: #e6edf3; --muted: #8b98a5; --accent: #6e8dff; --accent2: #2dd4bf; --accent-contrast: #0d1117; --focus: #6e8dff;
--ok: #34d399; --ok-bg: #10281d; --info: #8ab4f8; --info-bg: #16283d; --warn: #f5b84d; --warn-bg: #3a2b0c; --err: #f1798d; --err-bg: #3b1620; --lock: #b7c0cc; --lock-bg: #232932;
--nav-bg: #0a1220; --nav-text: #cdd9f0; --nav-muted: #7c8bb0; --nav-border: #1c2740; --nav-hover: #131f36; --nav-active-bg: #1d3358; --nav-active-text: #ffffff;
--shadow-sm: 0 1px 2px rgba(0, 0, 0, .45); --shadow-md: 0 10px 24px rgba(0, 0, 0, .5), 0 2px 8px rgba(0, 0, 0, .35);
--bg: #05060a; --surface: #0b0d14; --surface-2: #121622; --border: rgba(255, 255, 255, .08); --text: #f5f7ff; --muted: #9aa4b5; --accent: #4d9dff; --accent2: #20d4f5; --accent-contrast: #ffffff; --focus: #20d4f5; --border-strong: #5f6b7c;
--ok: #34d399; --ok-bg: #0d2219; --info: #8ab4f8; --info-bg: #111d33; --warn: #f5b84d; --warn-bg: #2e220a; --err: #f1798d; --err-bg: #2f121a; --lock: #b7c0cc; --lock-bg: #181c26;
--nav-bg: #05060a; --nav-text: #c9d1e0; --nav-muted: #7b8599; --nav-border: rgba(255, 255, 255, .08); --nav-hover: #0f121b; --nav-active-bg: #121622; --nav-active-text: #ffffff;
--shadow-sm: none; --shadow-md: 0 10px 30px rgba(0, 0, 0, .55), 0 0 0 1px rgba(255, 255, 255, .04);
--glow: rgba(37, 132, 255, .16);
} }
:root[data-theme='dark'] {
--bg: #0d1117; --surface: #161b22; --surface-2: #1c2129; --border: #262c36; --text: #e6edf3; --muted: #8b98a5; --accent: #6e8dff; --accent2: #2dd4bf; --accent-contrast: #0d1117; --focus: #6e8dff;
--ok: #34d399; --ok-bg: #10281d; --info: #8ab4f8; --info-bg: #16283d; --warn: #f5b84d; --warn-bg: #3a2b0c; --err: #f1798d; --err-bg: #3b1620; --lock: #b7c0cc; --lock-bg: #232932;
--nav-bg: #0a1220; --nav-text: #cdd9f0; --nav-muted: #7c8bb0; --nav-border: #1c2740; --nav-hover: #131f36; --nav-active-bg: #1d3358; --nav-active-text: #ffffff;
--shadow-sm: 0 1px 2px rgba(0, 0, 0, .45); --shadow-md: 0 10px 24px rgba(0, 0, 0, .5), 0 2px 8px rgba(0, 0, 0, .35);
--bg: #05060a; --surface: #0b0d14; --surface-2: #121622; --border: rgba(255, 255, 255, .08); --text: #f5f7ff; --muted: #9aa4b5; --accent: #4d9dff; --accent2: #20d4f5; --accent-contrast: #ffffff; --focus: #20d4f5; --border-strong: #5f6b7c;
--ok: #34d399; --ok-bg: #0d2219; --info: #8ab4f8; --info-bg: #111d33; --warn: #f5b84d; --warn-bg: #2e220a; --err: #f1798d; --err-bg: #2f121a; --lock: #b7c0cc; --lock-bg: #181c26;
--nav-bg: #05060a; --nav-text: #c9d1e0; --nav-muted: #7b8599; --nav-border: rgba(255, 255, 255, .08); --nav-hover: #0f121b; --nav-active-bg: #121622; --nav-active-text: #ffffff;
--shadow-sm: none; --shadow-md: 0 10px 30px rgba(0, 0, 0, .55), 0 0 0 1px rgba(255, 255, 255, .04);
--glow: rgba(37, 132, 255, .16);
}
* { box-sizing: border-box; }
html { color-scheme: light dark; }
body { margin: 0; font: 16px/1.55 var(--font); background: var(--bg); color: var(--text); }
body, .btn, .badge, .card, input, select, a, .alert { transition: background-color .15s ease, border-color .15s ease, color .15s ease, box-shadow .15s ease; }
h1 { font-size: 1.7rem; font-weight: 700; margin: 0 0 var(--s3); letter-spacing: -0.015em; } h2 { font-size: 1.15rem; font-weight: 600; margin: 0 0 var(--s3); } h3 { font-size: 1rem; font-weight: 600; margin: 0 0 var(--s2); }
a { color: var(--accent); } p { margin: 0 0 var(--s3); } .muted { color: var(--muted); } .small { font-size: .9rem; }
body, .btn, .badge, .card, input, select, textarea, a, .alert { transition: background-color .15s ease, border-color .15s ease, color .15s ease, box-shadow .15s ease; }
h1 { font-size: 1.75rem; font-weight: 700; margin: 0 0 var(--s3); letter-spacing: -0.025em; line-height: 1.2; } h2 { font-size: 1.15rem; font-weight: 600; margin: 0 0 var(--s3); } h3 { font-size: 1rem; font-weight: 600; margin: 0 0 var(--s2); }
a { color: var(--accent); text-decoration-thickness: 1px; text-underline-offset: 3px; text-decoration-color: color-mix(in srgb, currentColor 45%, transparent); } a:hover { text-decoration-color: currentColor; } p { margin: 0 0 var(--s3); } .muted { color: var(--muted); } .small { font-size: .9rem; }
:focus-visible { outline: 2px solid var(--focus); outline-offset: 2px; border-radius: 6px; }
.skip { position: absolute; left: -999px; } .skip:focus { left: var(--s3); top: var(--s3); background: var(--surface); padding: var(--s2) var(--s3); z-index: 10; }
.shell { display: grid; grid-template-columns: 288px 1fr; min-height: 100vh; }
.nav { background: var(--nav-bg); border-right: 1px solid var(--nav-border); padding: var(--s4) var(--s3) var(--s3); display: flex; flex-direction: column; gap: 2px; }
.nav .brand { font-weight: 700; font-size: 1.2rem; letter-spacing: -0.01em; color: #fff; padding: 0 var(--s2) var(--s4); }
.nav a { display: block; padding: 11px var(--s3); border-radius: var(--radius-sm); color: var(--nav-text); text-decoration: none; font-size: .96rem; }
.shell { display: grid; grid-template-columns: 288px minmax(0, 1fr); min-height: 100vh; }
.nav { background: radial-gradient(420px 260px at 0% 0%, rgba(37, 132, 255, .14), transparent 70%), var(--nav-bg); border-right: 1px solid var(--nav-border); padding: var(--s4) var(--s3) var(--s3); display: flex; flex-direction: column; gap: 2px; position: sticky; top: 0; height: 100vh; overflow-y: auto; }
.brandlink { display: block; padding: 0 var(--s2) var(--s4); text-decoration: none; color: #fff; border-radius: var(--radius-sm); }
.brand { display: inline-flex; align-items: center; gap: 10px; font-weight: 700; letter-spacing: -0.01em; }
.brandmark { display: block; width: 34px; height: 34px; flex: none; object-fit: contain; filter: drop-shadow(0 2px 6px rgba(60, 90, 255, .35)); }
.brandtext { display: flex; flex-direction: column; font-size: 1.08rem; line-height: 1.15; }
.brandtext small { font-size: .7rem; font-weight: 500; letter-spacing: .02em; opacity: .7; }
.nav a { display: flex; align-items: center; gap: 12px; padding: 10px var(--s3); border-radius: var(--radius-sm); color: var(--nav-text); text-decoration: none; font-size: .95rem; position: relative; }
.nav a .icon { width: 18px; height: 18px; opacity: .85; }
.nav a:hover { background: var(--nav-hover); color: #fff; }
.nav a[aria-current='page'] { background: var(--nav-active-bg); color: var(--nav-active-text); font-weight: 600; }
.nav a[aria-current='page'] .icon { opacity: 1; }
.nav a[aria-current='page']::before { content: ''; position: absolute; left: -8px; top: 8px; bottom: 8px; width: 3px; border-radius: 3px; background: var(--brand-gradient); }
.nav .group { margin: 0; }
.nav .group > summary { list-style: none; cursor: pointer; margin: var(--s2) var(--s1) 2px; padding: 8px var(--s2); font-size: .74rem; font-weight: 700; text-transform: uppercase; letter-spacing: .07em; color: var(--nav-muted); display: flex; align-items: center; justify-content: space-between; border-radius: var(--radius-sm); }
.nav .group > summary { list-style: none; cursor: pointer; margin: var(--s3) var(--s1) 2px; padding: 6px var(--s2); font-size: .72rem; font-weight: 700; text-transform: uppercase; letter-spacing: .08em; color: var(--nav-muted); display: flex; align-items: center; justify-content: space-between; border-radius: var(--radius-sm); }
.nav .group > summary::-webkit-details-marker { display: none; }
.nav .group > summary:hover { color: #fff; background: var(--nav-hover); }
.nav .group > summary::after { content: '▸'; font-size: .7rem; transition: transform .15s ease; }
.nav .group[open] > summary::after { transform: rotate(90deg); }
.nav .group .items { display: flex; flex-direction: column; gap: 2px; padding-bottom: var(--s2); }
.nav .spacer { flex: 1; }
.nav .who { padding: var(--s2); color: var(--nav-text); }
.nav .who .org { color: #fff; font-weight: 600; }
.main { padding: var(--s5) var(--s4); max-width: 1240px; width: 100%; }
.nav .group > summary:hover { color: #fff; }
.nav .group > summary .chev { width: 14px; height: 14px; transition: transform .2s ease; }
.nav .group[open] > summary .chev { transform: rotate(90deg); }
.nav .group .items { display: flex; flex-direction: column; gap: 2px; padding-bottom: var(--s1); }
.nav .spacer { flex: 1; min-height: var(--s4); }
.nav .who { display: flex; align-items: center; gap: 10px; margin: var(--s2) 0; padding: var(--s3) var(--s2) var(--s2); border-top: 1px solid var(--nav-border); color: var(--nav-text); }
.nav .who > .small { display: flex; flex-direction: column; line-height: 1.35; min-width: 0; }
.nav .who .name { color: #fff; font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.nav .who .role { color: var(--nav-muted); }
.avatar { display: inline-grid; place-items: center; width: 36px; height: 36px; border-radius: 50%; background: var(--brand-btn); color: #fff; font-weight: 700; font-size: .85rem; flex: none; }
.navactions { display: flex; gap: var(--s2); padding: 0 var(--s1); }
.nav .btn { background: transparent; border-color: var(--nav-border); color: var(--nav-text); box-shadow: none; flex: 1; }
.nav .btn:hover { background: var(--nav-hover); color: #fff; transform: none; box-shadow: none; }
.nav .who .org { color: var(--nav-muted); font-weight: 600; }
.main { padding: var(--s5) var(--s5) var(--s4); max-width: 1280px; width: 100%; min-width: 0; display: flex; flex-direction: column; min-height: 100vh; }
.main > .site-footer { margin-top: auto; }
/* Breite Seiten (z. B. Domain-Aufstellung): Inhalt nutzt die volle Fensterbreite */
.main:has(.page-wide) { max-width: 1800px; }
.page-wide td select { min-width: 210px; }
.page-wide td .row { flex-wrap: nowrap; gap: var(--s2); }
.page-wide td:last-child > .row { flex-direction: column; align-items: stretch; gap: 6px; }
.page-wide td .btn { white-space: nowrap; }
.main > .alert.warn { margin-bottom: var(--s4); }
.topbar { display: none; } .bottomnav { display: none; }
@media (max-width: 800px) {
.shell { grid-template-columns: 1fr; } .nav { display: none; } .nav.open { display: flex; position: fixed; inset: 0 20% 56px 0; z-index: 5; box-shadow: 0 0 0 100vmax rgba(0,0,0,.4); overflow: auto; }
.shell { grid-template-columns: minmax(0, 1fr); } .nav { display: none; } .nav.open { display: flex; position: fixed; inset: 0 20% 56px 0; height: auto; z-index: 5; box-shadow: 0 0 0 100vmax rgba(0,0,0,.4); overflow: auto; }
.topbar { display: flex; align-items: center; justify-content: space-between; gap: var(--s2); padding: var(--s3); background: var(--surface); border-bottom: 1px solid var(--border); }
.main { padding: var(--s4) var(--s3) calc(var(--s4) + 56px); }
.main { padding: var(--s4) var(--s3) calc(var(--s4) + 56px); min-height: 0; }
/* Tabellen als Karten: jede Zeile ein Block, Zellen mit ihrer Spaltenüberschrift (data-label, siehe TableCards) */
.tablewrap { border: none; border-radius: 0; overflow: visible; }
.tablewrap table, .tablewrap tbody, .tablewrap tr, .tablewrap td { display: block; width: 100%; }
.tablewrap thead { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); }
.tablewrap tbody tr { border: 1px solid var(--border); border-radius: var(--radius); padding: 10px 14px; margin-bottom: 10px; }
.tablewrap tbody tr:hover { background: transparent; }
.tablewrap td, .tablewrap th:first-child, .tablewrap td:first-child { border: none; padding: 5px 0; }
.tablewrap td[data-label] { display: grid; grid-template-columns: minmax(92px, 36%) minmax(0, 1fr); gap: 12px; align-items: baseline; }
.tablewrap td[data-label] > * { grid-column: 2; }
.tablewrap tbody th { display: inline-block; border: none; background: none; padding: 4px 12px 4px 0; }
.page-wide td .row { flex-wrap: wrap; }
.tablewrap td[data-label]::before { content: attr(data-label); font-size: .72rem; font-weight: 600; text-transform: uppercase; letter-spacing: .06em; color: var(--muted); }
.tablewrap td:first-child { font-weight: 600; }
.tablewrap td:first-child[data-label] { display: block; padding-bottom: 8px; margin-bottom: 4px; border-bottom: 1px solid var(--border); }
.tablewrap td:first-child::before { content: none; }
.tablewrap td:empty { display: none; }
.topbar .brand { color: var(--text); } .topbar .brandmark { width: 30px; height: 30px; }
.bottomnav { display: flex; position: fixed; left: 0; right: 0; bottom: 0; z-index: 6; background: var(--surface); border-top: 1px solid var(--border); box-shadow: var(--shadow-md); padding-bottom: env(safe-area-inset-bottom, 0); }
.bottomnav a, .bottomnav button { flex: 1; display: flex; flex-direction: column; align-items: center; gap: 2px; padding: 8px 2px 10px; font-size: .72rem; color: var(--muted); text-decoration: none; background: none; border: none; font: inherit; min-height: 56px; }
.bottomnav .ic { font-size: 1.15rem; line-height: 1; }
.bottomnav a[aria-current='page'] { color: var(--accent2); font-weight: 600; }
.bottomnav .ic { width: 22px; height: 22px; }
.bottomnav a[aria-current='page'] { color: var(--accent); font-weight: 600; }
}
.card { background: var(--surface); border: 1px solid var(--border); border-radius: var(--radius); padding: var(--s4); margin-bottom: var(--s4); box-shadow: var(--shadow-sm); }
.grid { display: grid; gap: var(--s4); grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); }
.stat { font-size: 2rem; font-weight: 700; line-height: 1.1; letter-spacing: -0.02em; } .row { display: flex; gap: var(--s3); align-items: center; flex-wrap: wrap; } .row.between { justify-content: space-between; }
.card { background: var(--surface); border: 1px solid var(--border); border-radius: var(--radius-lg); padding: var(--s4); margin-bottom: var(--s4); box-shadow: var(--shadow-sm); }
.grid { display: grid; gap: var(--s4); grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); margin-bottom: var(--s4); align-items: start; }
.grid > .card { margin-bottom: 0; }
.grid > .card:hover { box-shadow: var(--shadow-md); }
.grid.wide { grid-template-columns: repeat(auto-fit, minmax(min(100%, 380px), 1fr)); }
.list { list-style: none; margin: 0; padding: 0; }
.list li { display: flex; align-items: center; justify-content: space-between; gap: var(--s3); padding: 10px 0; border-top: 1px solid var(--border); }
.list li:first-child { border-top: none; }
.list a { display: flex; flex-direction: column; min-width: 0; text-decoration: none; }
.list a .title { font-weight: 600; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
.list a:hover .title { text-decoration: underline; }
.list a .meta { font-size: .85rem; color: var(--muted); }
.stat { font-size: 2.25rem; font-variant-numeric: tabular-nums; font-weight: 700; line-height: 1.1; letter-spacing: -0.02em; } .row { display: flex; gap: var(--s3); align-items: center; flex-wrap: wrap; } .row.between { justify-content: space-between; }
.btn { font: inherit; font-weight: 500; padding: 10px 18px; border-radius: var(--radius-sm); border: 1px solid var(--border); background: var(--surface); color: var(--text); cursor: pointer; min-height: 44px; box-shadow: var(--shadow-sm); }
.btn:hover { background: var(--surface-2); transform: translateY(-1px); box-shadow: var(--shadow-md); }
.btn:active { transform: translateY(0); }
.btn.primary { background: var(--accent); color: var(--accent-contrast); border-color: var(--accent); font-weight: 600; }
.btn.primary:hover { filter: brightness(1.08); }
.btn.primary { background: var(--brand-btn); color: #fff; border-color: transparent; font-weight: 600; }
.btn.primary:hover { background: var(--brand-btn); filter: brightness(1.1); box-shadow: 0 6px 20px rgba(37, 132, 255, .3); }
.btn.danger { color: var(--err); border-color: var(--err); } .btn:disabled { opacity: .55; cursor: not-allowed; transform: none; box-shadow: none; } .btn.small { min-height: 36px; padding: 6px 12px; font-size: .9rem; }
.field { display: grid; gap: 6px; margin-bottom: var(--s3); } .field label { font-weight: 600; font-size: .9rem; }
input, select { font: inherit; padding: 10px 12px; border: 1px solid var(--border); border-radius: var(--radius-sm); background: var(--surface); color: var(--text); min-height: 44px; width: 100%; }
input:focus-visible, select:focus-visible { border-color: var(--accent); box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 22%, transparent); outline: none; }
input, select, textarea { font: inherit; padding: 10px 12px; border: 1px solid var(--border-strong); border-radius: var(--radius-sm); background: var(--surface); color: var(--text); min-height: 44px; width: 100%; }
input:focus-visible, select:focus-visible, textarea:focus-visible { border-color: var(--accent); box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 22%, transparent); outline: none; }
button { font: inherit; color: inherit; }
input[type='checkbox'], input[type='radio'] { width: 20px; height: 20px; min-height: 0; padding: 0; flex: none; accent-color: var(--accent); cursor: pointer; }
.cols { display: grid; gap: var(--s3); grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); }
table { width: 100%; border-collapse: collapse; } th, td { text-align: left; padding: 12px var(--s3); border-bottom: 1px solid var(--border); vertical-align: top; } th { font-size: .78rem; font-weight: 600; text-transform: uppercase; letter-spacing: .06em; color: var(--muted); background: var(--surface-2); }
tbody tr:hover { background: var(--surface-2); }
tbody tr:hover { background: var(--surface-2); } tbody tr:last-child td { border-bottom: none; }
td.mono, td .mono, td code { white-space: nowrap; word-break: normal; }
td a { text-decoration: none; font-weight: 500; } td a:hover { text-decoration: underline; }
.tablewrap { overflow-x: auto; border-radius: var(--radius-sm); border: 1px solid var(--border); }
.tablewrap table { border: none; } .tablewrap th:first-child, .tablewrap td:first-child { padding-left: var(--s3); }
.badge { display: inline-flex; gap: 6px; align-items: center; padding: 3px 10px; border-radius: 999px; font-size: .78rem; font-weight: 600; }
.badge { white-space: nowrap; display: inline-flex; gap: 6px; align-items: center; padding: 3px 10px; border-radius: 999px; font-size: .78rem; font-weight: 600; }
.badge.ok { background: var(--ok-bg); color: var(--ok); } .badge.info { background: var(--info-bg); color: var(--info); } .badge.warn { background: var(--warn-bg); color: var(--warn); } .badge.err { background: var(--err-bg); color: var(--err); } .badge.lock { background: var(--lock-bg); color: var(--lock); }
.alert { border-radius: var(--radius-sm); padding: var(--s3); margin-bottom: var(--s3); border: 1px solid transparent; } .alert.err { background: var(--err-bg); color: var(--err); } .alert.ok { background: var(--ok-bg); color: var(--ok); } .alert.warn { background: var(--warn-bg); color: var(--warn); } .alert.info { background: var(--info-bg); color: var(--info); }
.empty { text-align: center; padding: var(--s5) var(--s3); color: var(--muted); }
@ -85,8 +145,17 @@ tbody tr:hover { background: var(--surface-2); }
.productgrid { display: grid; gap: var(--s3); grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); }
.productcard { background: var(--surface); border: 1px solid var(--border); border-radius: var(--radius); padding: var(--s4); box-shadow: var(--shadow-sm); display: flex; flex-direction: column; gap: 6px; }
.productcard h3 { margin: 0; font-size: 1.05rem; }
.productcard .id { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .82rem; color: var(--muted); }
.productcard .id { font-family: var(--font-mono); font-size: .82rem; color: var(--muted); }
.center { min-height: 100vh; display: grid; place-items: center; padding: var(--s3); } .auth { width: 100%; max-width: 420px; }
code, .mono { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: .9em; word-break: break-all; } .codes { columns: 2; background: var(--surface-2); padding: var(--s3); border-radius: var(--radius-sm); }
body:not(:has(.shell)) { display: flex; flex-direction: column; min-height: 100vh; background: radial-gradient(900px 480px at 50% 0%, var(--glow), transparent 70%), linear-gradient(rgba(127, 140, 170, .05) 1px, transparent 1px) 0 0 / 56px 56px, linear-gradient(90deg, rgba(127, 140, 170, .05) 1px, transparent 1px) 0 0 / 56px 56px, var(--bg); }
body:not(:has(.shell)) > .center { flex: 1; min-height: 0; }
body:not(:has(.shell)) .auth.card { box-shadow: var(--shadow-md); padding: var(--s5) var(--s4); }
.site-header { display: flex; justify-content: center; padding: var(--s5) var(--s3) 0; color: var(--text); }
body:has(.shell) > .site-header, body:has(.shell) > .site-footer { display: none; }
.site-footer { display: flex; flex-wrap: wrap; justify-content: center; gap: 6px var(--s2); padding: var(--s4) var(--s3); font-size: .85rem; color: var(--muted); }
.main > .site-footer { justify-content: flex-start; padding: var(--s5) 0 0; margin-top: auto; border-top: 0; }
code, .mono { font-family: var(--font-mono); font-size: .9em; word-break: break-all; } .codes { columns: 2; background: var(--surface-2); padding: var(--s3); border-radius: var(--radius-sm); }
.icon { width: 1.1em; height: 1.1em; flex: none; vertical-align: -0.18em; }
.impersonate { position: sticky; top: 0; z-index: 100; width: 100%; background: var(--warn-bg); color: var(--warn); border-bottom: 2px solid var(--warn); padding: 8px 16px; display: flex; flex-wrap: wrap; gap: 8px; align-items: center; justify-content: center; text-align: center; }
.sr { position: absolute; width: 1px; height: 1px; overflow: hidden; clip: rect(0 0 0 0); }
@media (prefers-reduced-motion: reduce) { * { animation: none !important; transition: none !important; } }

BIN
apps/web/src/app/icon.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 2.5 KiB

View file

@ -1,14 +1,16 @@
import type { Metadata } from 'next';
import type { ReactNode } from 'react';
import { Inter } from 'next/font/google';
import { Geist, Geist_Mono } from 'next/font/google';
import './globals.css';
import { SessionProvider } from '@/lib/session';
import { Brand, SiteFooter } from '@/components/Brand';
const inter = Inter({ subsets: ['latin'], variable: '--font-inter', display: 'swap' });
const geist = Geist({ subsets: ['latin'], variable: '--font-geist', display: 'swap' });
const geistMono = Geist_Mono({ subsets: ['latin'], variable: '--font-geist-mono', display: 'swap' });
export const metadata: Metadata = { title: { default: 'Kundencenter', template: '%s · Kundencenter' }, robots: { index: false } };
// Verhindert einen kurzen Blitz der falschen Darstellung: setzt die gespeicherte Wahl (falls vorhanden), bevor die Seite gemalt wird.
const themeInit = "try{var t=localStorage.getItem('kc-theme');if(t==='light'||t==='dark')document.documentElement.setAttribute('data-theme',t);}catch(e){}";
export default function RootLayout({ children }: { children: ReactNode }) {
return <html lang="de" className={inter.variable}><head><script dangerouslySetInnerHTML={{ __html: themeInit }} /></head>
<body><a className="skip" href="#main">Zum Inhalt springen</a><SessionProvider>{children}</SessionProvider></body></html>;
return <html lang="de" className={`${geist.variable} ${geistMono.variable}`}><head><script dangerouslySetInnerHTML={{ __html: themeInit }} /></head>
<body><a className="skip" href="#main">Zum Inhalt springen</a><header className="site-header"><Brand /></header><SessionProvider>{children}</SessionProvider><SiteFooter /></body></html>;
}

View file

@ -10,7 +10,8 @@ import { ThemeToggle } from '@/components/ThemeToggle';
export default function Login() {
const r = useRouter(); const { me, reload } = useSession();
const [step, setStep] = useState<'pw' | 'mfa'>('pw');
const [err, setErr] = useState(''); const [busy, setBusy] = useState(false);
const [err, setErr] = useState(''); const [busy, setBusy] = useState(false); const [regOpen, setRegOpen] = useState(false);
useEffect(() => { api<{ enabled: boolean }>('GET', '/auth/registration').then((r) => setRegOpen(r.enabled)).catch(() => undefined); }, []);
useEffect(() => { if (me?.pendingMfa) setStep('mfa'); else if (me) r.replace('/dashboard'); }, [me, r]);
async function submit(e: FormEvent<HTMLFormElement>) {
@ -40,7 +41,7 @@ export default function Login() {
)}
<button className="btn primary" disabled={busy} type="submit">{busy ? 'Bitte warten …' : step === 'pw' ? 'Anmelden' : 'Bestätigen'}</button>
</form>
{step === 'pw' && <p className="small" style={{ marginTop: 16 }}><Link href="/passwort-vergessen">Passwort vergessen?</Link></p>}
{step === 'pw' && <p className="small" style={{ marginTop: 16 }}><Link href="/passwort-vergessen">Passwort vergessen?</Link>{regOpen && <> · <Link href="/registrieren">Neu hier? Registrieren</Link></>}</p>}
</div></main>
);
}

View file

@ -0,0 +1,38 @@
'use client';
import { useEffect, useState, type FormEvent } from 'react';
import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { Alert, Field } from '@/components/ui';
/** Selbstregistrierung (#36) – nur sichtbar, wenn in der Verwaltung eingeschaltet. */
export default function Registrieren() {
const [enabled, setEnabled] = useState<boolean | null>(null); const [type, setType] = useState<'private' | 'business'>('private');
const [done, setDone] = useState(false); const [err, setErr] = useState(''); const [busy, setBusy] = useState(false);
useEffect(() => { api<{ enabled: boolean }>('GET', '/auth/registration').then((r) => setEnabled(r.enabled)).catch(() => setEnabled(false)); }, []);
async function submit(e: FormEvent<HTMLFormElement>) {
e.preventDefault(); setErr(''); setBusy(true);
const f = new FormData(e.currentTarget); const v = (k: string) => String(f.get(k) ?? '').trim() || undefined;
try {
await api('POST', '/auth/register', { type, name: v('name'), contactName: type === 'business' ? v('contactName') : undefined, email: v('email'), password: f.get('password'), repeat: f.get('repeat'), vatId: type === 'business' ? v('vatId') : undefined, acceptPrivacy: f.get('privacy') === 'on' });
setDone(true);
} catch (x) { setErr(errMsg(x)); } finally { setBusy(false); }
}
return <main id="main" className="center"><div className="auth card"><h1>Registrieren</h1>
{enabled === null ? <p className="muted" role="status">Wird geladen …</p>
: !enabled ? <Alert kind="info">Eine Selbstregistrierung ist derzeit nicht möglich. Bitte wenden Sie sich an uns, wir legen Ihren Zugang an.</Alert>
: done ? <Alert kind="ok">Fast geschafft: Bitte prüfen Sie Ihr Postfach und bestätigen Sie Ihre E-Mail-Adresse über den Link in unserer Nachricht.</Alert>
: <form onSubmit={submit}>
{err && <Alert kind="err">{err}</Alert>}
<fieldset style={{ border: 0, padding: 0, margin: '0 0 12px' }}><legend className="small">Kundenart</legend>
<div className="row">{([['private', 'Privatkunde'], ['business', 'Geschäftskunde']] as const).map(([k, l]) => <label key={k} className="row"><input type="radio" name="ctype" checked={type === k} onChange={() => setType(k)} style={{ width: 20, minHeight: 20 }} />{l}</label>)}</div></fieldset>
<Field id="name" label={type === 'business' ? 'Firmenname' : 'Vor- und Nachname'}><input id="name" name="name" required minLength={2} autoComplete={type === 'business' ? 'organization' : 'name'} /></Field>
{type === 'business' && <><Field id="contactName" label="Ansprechpartner"><input id="contactName" name="contactName" autoComplete="name" /></Field>
<Field id="vatId" label="USt-IdNr." hint="Optional, z. B. DE123456789"><input id="vatId" name="vatId" /></Field></>}
<Field id="email" label="E-Mail"><input id="email" name="email" type="email" required autoComplete="email" /></Field>
<Field id="password" label="Passwort" hint="Mindestens 12 Zeichen."><input id="password" name="password" type="password" minLength={12} required autoComplete="new-password" /></Field>
<Field id="repeat" label="Passwort wiederholen"><input id="repeat" name="repeat" type="password" minLength={12} required autoComplete="new-password" /></Field>
<label className="row small" style={{ gap: 8, margin: '8px 0 16px' }}><input type="checkbox" name="privacy" required style={{ width: 20, minHeight: 20 }} />Ich habe die Datenschutzhinweise gelesen und bin mit der Verarbeitung meiner Angaben zur Einrichtung des Zugangs einverstanden.</label>
<button className="btn primary" type="submit" disabled={busy}>{busy ? 'Bitte warten …' : 'Registrieren'}</button>
</form>}
<p className="small" style={{ marginTop: 16 }}><Link href="/login">Zur Anmeldung</Link></p></div></main>;
}

View file

@ -0,0 +1,37 @@
'use client';
import { useEffect, useState } from 'react';
import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { Alert } from '@/components/ui';
import { ThemeToggle } from '@/components/ThemeToggle';
interface Ev { id: string; kind: 'incident' | 'maintenance'; title: string; component: string | null; impact: string; state: string; startsAt: string; endsAt: string | null; updates: { state: string; body: string; at: string }[] }
interface St { overall: 'ok' | 'maintenance' | 'minor' | 'major'; current: Ev[]; recent: Ev[] }
const STATE: Record<string, string> = { investigating: 'Wird untersucht', identified: 'Ursache gefunden', monitoring: 'Wird beobachtet', resolved: 'Behoben', planned: 'Geplant', in_progress: 'Läuft', completed: 'Abgeschlossen' };
const OVERALL = { ok: ['ok', '✓', 'Alle Systeme laufen normal'], maintenance: ['info', 'ⓘ', 'Wartung läuft'], minor: ['warn', '▲', 'Teilweise Einschränkungen'], major: ['err', '✕', 'Größere Störung'] } as const;
const fmt = (d: string) => new Date(d).toLocaleString('de-DE', { dateStyle: 'medium', timeStyle: 'short' });
function Event({ e }: { e: Ev }) {
return (<article className="card">
<h3 style={{ margin: 0 }}>{e.title}</h3>
<p className="small muted" style={{ margin: '4px 0 8px' }}>{e.kind === 'maintenance' ? 'Wartung' : 'Störung'}{e.component ? ` · ${e.component}` : ''} · {STATE[e.state] ?? e.state} · {e.kind === 'maintenance' ? `${fmt(e.startsAt)}${e.endsAt ? ` – ${fmt(e.endsAt)}` : ''}` : `seit ${fmt(e.startsAt)}`}</p>
<ul className="small" style={{ margin: 0, paddingLeft: 18 }}>{e.updates.map((u, i) => <li key={i}><strong>{STATE[u.state] ?? u.state}</strong> ({fmt(u.at)}): {u.body}</li>)}</ul>
</article>);
}
/** Öffentliche Statusseite (#23) – zeigt nur vom Personal veröffentlichte Meldungen. */
export default function Status() {
const [s, setS] = useState<St | null>(null); const [err, setErr] = useState('');
useEffect(() => { const load = () => api<St>('GET', '/public/status').then(setS).catch((e) => setErr(errMsg(e))); void load(); const t = setInterval(load, 60_000); return () => clearInterval(t); }, []);
const o = s ? OVERALL[s.overall] : null;
return <main id="main" style={{ maxWidth: 760, margin: '0 auto', padding: '32px 16px' }}>
<div className="row between"><h1 style={{ margin: 0 }}>Systemstatus</h1><ThemeToggle compact /></div>
{err && <Alert kind="err">{err}</Alert>}
{!s ? <p className="muted" role="status">Wird geladen …</p> : (<>
<div className="card" role="status"><span className={`badge ${o![0]}`}><span aria-hidden="true">{o![1]}</span>{o![2]}</span></div>
{s.current.length > 0 && <><h2>Aktuell</h2>{s.current.map((e) => <Event key={e.id} e={e} />)}</>}
<h2>Letzte 14 Tage</h2>
{s.recent.length === 0 ? <p className="muted">Keine Störungen oder Wartungen.</p> : s.recent.map((e) => <Event key={e.id} e={e} />)}
</>)}
<p className="small" style={{ marginTop: 24 }}><Link href="/login">Zum Kundencenter</Link></p>
</main>;
}

View file

@ -0,0 +1,12 @@
/** Markenzeichen und Herstellerhinweis (KC@FlessingLabs). */
export const Brand = ({ sub = true }: { sub?: boolean }) => (
<span className="brand"><img className="brandmark" src="/brand/fl-mark.png" width={34} height={34} alt="" /><span className="brandtext">Kundencenter{sub && <small>by FlessingLabs</small>}</span></span>
);
export const SiteFooter = () => (
<footer className="site-footer">
<span>KC@FlessingLabs</span><span aria-hidden="true">·</span>
<span>© {Math.max(2026, new Date().getFullYear())} FlessingLabs</span><span aria-hidden="true">·</span>
<a href="https://flessinglabs.com" target="_blank" rel="noopener">flessinglabs.com</a>
</footer>
);

View file

@ -5,18 +5,19 @@ import { useSearchParams } from 'next/navigation';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Empty, Field, eur } from '@/components/ui';
import { csvText, csvValue } from '@/lib/csv';
interface Rec { id: string; domain: string; tld: string; orgId: string | null; customer: string | null; customerNumber: string | null; source: string; termMonths: number | null; costNetCents: number | null; costGrossCents: number | null; setupCostCents: number; sellNetCents: number | null; taxBp: number; sellGrossCents: number | null; profitNetCents: number | null; procurement: 'open' | 'ordered' | 'external'; orderedAt: string | null; note: string | null }
interface Res { id: string; name: string; type: string; orgId: string | null }
const PROC = { open: 'Bei KCS zu bestellen', ordered: 'Bei KCS bestellt', external: 'Anderer Anbieter' } as const;
const money = (c: number | null) => c === null ? '–' : eur(c);
const csvNum = (c: number | null) => c === null ? '' : (c / 100).toFixed(2).replace('.', ',');
const csvCell = (v: string | number | null) => `"${String(v ?? '').replace(/"/g, '""')}"`;
/** CSV für Excel (Semikolon, UTF-8 mit BOM): Bestellliste bzw. Gesamtaufstellung. */
function download(rows: Rec[], name: string) {
const head = ['Domain', 'Endung', 'Laufzeit (Monate)', 'Kunde', 'Kundennr.', 'EK brutto', 'EK netto', 'Setup EK brutto', 'VK brutto', 'VK netto', 'USt %', 'Gewinn netto', 'Status', 'bestellt am', 'Notiz'];
const lines = rows.map((r) => [r.domain, r.tld, r.termMonths, r.customer, r.customerNumber, csvNum(r.costGrossCents), csvNum(r.costNetCents), csvNum(r.setupCostCents), csvNum(r.sellGrossCents), csvNum(r.sellNetCents), r.taxBp / 100, csvNum(r.profitNetCents), PROC[r.procurement], r.orderedAt ? new Date(r.orderedAt).toLocaleDateString('de-DE') : '', r.note].map(csvCell).join(';'));
const url = URL.createObjectURL(new Blob(['' + [head.map(csvCell).join(';'), ...lines].join('\r\n')], { type: 'text/csv;charset=utf-8' }));
// Texte (Domain, Kunde, Notiz …) neutralisiert, Beträge/Zahlen als Werte.
const lines = rows.map((r) => [csvText(r.domain), csvText(r.tld), csvValue(r.termMonths), csvText(r.customer), csvText(r.customerNumber), csvValue(csvNum(r.costGrossCents)), csvValue(csvNum(r.costNetCents)), csvValue(csvNum(r.setupCostCents)), csvValue(csvNum(r.sellGrossCents)), csvValue(csvNum(r.sellNetCents)), csvValue(r.taxBp / 100), csvValue(csvNum(r.profitNetCents)), csvText(PROC[r.procurement]), csvText(r.orderedAt ? new Date(r.orderedAt).toLocaleDateString('de-DE') : ''), csvText(r.note)].join(';'));
const url = URL.createObjectURL(new Blob(['' + [head.map(csvText).join(';'), ...lines].join('\r\n')], { type: 'text/csv;charset=utf-8' }));
const a = document.createElement('a'); a.href = url; a.download = name; document.body.appendChild(a); a.click(); a.remove(); URL.revokeObjectURL(url);
}
export function DomainRecords({ orgId }: { orgId?: string }) {
@ -35,7 +36,7 @@ export function DomainRecords({ orgId }: { orgId?: string }) {
{err && <Alert kind="err">{err}</Alert>}{ok && <Alert kind="ok">{ok}</Alert>}
{w && <div className="card"><div className="cols">
<form onSubmit={add}><Field id={`nd${orgId ?? ''}`} label="Domain manuell erfassen"><input id={`nd${orgId ?? ''}`} name="domain" placeholder="beispiel.de" required autoComplete="off" /></Field><button className="btn primary" type="submit">Erfassen</button></form>
<form onSubmit={fromRes}><Field id={`nr${orgId ?? ''}`} label="Domains eines Hosting-Kontos übernehmen" hint="Liest die Domains aus KeyHelp (ohne Subdomains)."><select id={`nr${orgId ?? ''}`} name="res" defaultValue=""><option value="">Konto wählen …</option>{res.map((r) => <option key={r.id} value={r.id}>{r.name}</option>)}</select></Field><button className="btn" type="submit">Übernehmen</button></form></div></div>}
<form onSubmit={fromRes}><Field id={`nr${orgId ?? ''}`} label="Domains eines Hosting-Kontos übernehmen" hint="Liest die Domains aus dem Hosting-Panel (ohne Subdomains)."><select id={`nr${orgId ?? ''}`} name="res" defaultValue=""><option value="">Konto wählen …</option>{res.map((r) => <option key={r.id} value={r.id}>{r.name}</option>)}</select></Field><button className="btn" type="submit">Übernehmen</button></form></div></div>}
<div className="card">
<div className="cols"><Field id={`q${orgId ?? ''}`} label="Suche"><input id={`q${orgId ?? ''}`} type="search" value={q} onChange={(e) => setQ(e.target.value)} placeholder="Domain" /></Field>
<Field id={`st${orgId ?? ''}`} label="Status"><select id={`st${orgId ?? ''}`} value={status} onChange={(e) => setStatus(e.target.value)}><option value="">Alle</option>{Object.entries(PROC).map(([k, v]) => <option key={k} value={k}>{v}</option>)}</select></Field></div>

View file

@ -1,14 +1,15 @@
'use client';
import { useCallback, useEffect, useState, type FormEvent } from 'react';
import { useCallback, useEffect, useRef, useState, type FormEvent } from 'react';
import QRCode from 'qrcode';
import { api, errMsg } from '@/lib/api';
import { copyText } from '@/lib/clipboard';
import { generatePassword, MIN_CHILD_PASSWORD } from '@/lib/password';
import { Alert, Empty, Field, fmt } from '@/components/ui';
import { Alert, Empty, Field, fmt, fmtDate } from '@/components/ui';
type Kind = 'domain' | 'email' | 'database' | 'ftp' | 'certificate';
type Kind = 'domain' | 'email' | 'database' | 'ftp' | 'certificate' | 'dns' | 'dirprotect';
interface Child { id: string; kind: Kind; name: string; state: string; validUntil?: string | null; details: Record<string, any> }
interface Kinds { kinds: { kind: Kind; canWrite: boolean }[]; panelLogin: boolean }
const LABEL: Record<Kind, string> = { domain: 'Domains', email: 'E-Mail', database: 'Datenbanken', ftp: 'FTP', certificate: 'SSL-Zertifikate' };
const LABEL: Record<Kind, string> = { domain: 'Domains', email: 'E-Mail', database: 'Datenbanken', ftp: 'FTP', certificate: 'SSL-Zertifikate', dns: 'DNS', dirprotect: 'Verzeichnisschutz' };
const STATE: Record<string, [string, string, string]> = { active: ['ok', '●', 'Aktiv'], disabled: ['lock', '⊘', 'Deaktiviert'], pending: ['info', '◐', 'Wird eingerichtet'], error: ['err', '✕', 'Fehler'], expired: ['warn', '▲', 'Abgelaufen'] };
const bytes = (b?: number | null) => (b == null ? '–' : b < 1024 ** 2 ? `${Math.max(0, Math.round(b / 1024))} KB` : b < 1024 ** 3 ? `${(b / 1024 ** 2).toFixed(1)} MB` : `${(b / 1024 ** 3).toFixed(1)} GB`);
const USAGE: Record<string, { label: string; bytes?: boolean }> = { disk_space: { label: 'Speicher', bytes: true }, traffic: { label: 'Traffic', bytes: true }, domains: { label: 'Domains' }, email_accounts: { label: 'Postfächer' }, databases: { label: 'Datenbanken' }, ftp_users: { label: 'FTP-Benutzer' }, subdomains: { label: 'Subdomains' } };
@ -56,15 +57,57 @@ function PasswordField({ id, value, onChange, label = 'Passwort' }: { id: string
{value && <button type="button" className="btn small" onClick={async () => setCopied(await copyText(value))}>{copied ? 'Kopiert ✓' : 'Kopieren'}</button>}</div></div>);
}
interface ConnInfo { host: string; alternativeHosts: string[]; usernames: string[]; ports: { protocol: string; port: number; security: 'tls' | 'starttls' }[]; profiles: { protocol: string; label: string; url: string }[] }
/** Verbindungsdaten eines Postfachs wie in KeyHelp: Apple-Profile (Link + QR-Code) und Daten für die manuelle Einrichtung. */
function ConnectionDialog({ resourceId, child, onClose }: { resourceId: string; child: Child; onClose: () => void }) {
const [info, setInfo] = useState<ConnInfo | null>(null); const [err, setErr] = useState(''); const [qr, setQr] = useState<Record<string, string>>({}); const [copied, setCopied] = useState('');
const closeRef = useRef<HTMLButtonElement>(null);
useEffect(() => {
closeRef.current?.focus(); const esc = (e: KeyboardEvent) => { if (e.key === 'Escape') onClose(); }; window.addEventListener('keydown', esc);
api<ConnInfo>('GET', `/resources/${resourceId}/children/email/${encodeURIComponent(child.id)}/connection`).then(async (i) => {
setInfo(i); setQr(Object.fromEntries(await Promise.all(i.profiles.map(async (p) => [p.protocol, await QRCode.toDataURL(p.url, { margin: 2, width: 200 })] as const))));
}).catch((e) => setErr(errMsg(e)));
return () => window.removeEventListener('keydown', esc);
}, [resourceId, child.id, onClose]);
const copy = async (k: string, v: string) => { if (await copyText(v)) { setCopied(k); setTimeout(() => setCopied(''), 1500); } };
const ports = (proto: string, sec: 'tls' | 'starttls') => info?.ports.filter((p) => sec === p.security && (proto === 'SMTP' ? p.protocol === 'SMTP' : p.protocol !== 'SMTP')).map((p) => <div key={p.protocol + p.port}><strong>{p.port}</strong> {p.protocol}</div>);
return (<div role="dialog" aria-modal="true" aria-labelledby="cd-t" onClick={(e) => { if (e.target === e.currentTarget) onClose(); }} style={{ position: 'fixed', inset: 0, background: 'rgba(0,0,0,.45)', display: 'grid', placeItems: 'center', padding: 16, zIndex: 50 }}>
<div className="card" style={{ maxWidth: 640, width: '100%', maxHeight: 'calc(100vh - 32px)', overflowY: 'auto' }}>
<div className="row between"><h2 id="cd-t" style={{ margin: 0 }}>Verbindungsdaten</h2><button ref={closeRef} className="btn small" onClick={onClose}>Schließen</button></div>
<p className="mono" style={{ marginTop: 4 }}>{child.name}</p>
{err && <Alert kind="err">{err}</Alert>}
{!info && !err && <p className="muted" role="status">Wird beim Anbieter gelesen …</p>}
{info && <>
<p>E-Mail-Programme wie Outlook, Thunderbird oder Apple Mail können das Postfach automatisch einrichten: Adresse und Passwort eingeben, den Rest holt das Programm selbst vom Server.</p>
<h3>Apple-Geräte (iPhone, iPad, Mac)</h3>
<p className="small">Den QR-Code mit der Kamera scannen oder den Link in Safari öffnen, das Profil laden und unter Einstellungen installieren. Das Passwort wird bei der Installation abgefragt. Die Links sind 24 Stunden gültig.</p>
<div className="row" style={{ gap: 16, alignItems: 'flex-start', flexWrap: 'wrap' }}>{info.profiles.map((p) => <div key={p.protocol} style={{ textAlign: 'center' }}>
{qr[p.protocol] && <img src={qr[p.protocol]} width={200} height={200} alt={`QR-Code: ${p.label}`} style={{ background: '#fff', borderRadius: 8, display: 'block' }} />}
<a className="small" href={p.url} target="_blank" rel="noopener noreferrer">{p.label}</a></div>)}</div>
<h3>Manuelle Einrichtung</h3>
<div className="tablewrap"><table><thead><tr><th><span className="sr">Angabe</span></th><th>Posteingang</th><th>Postausgang</th></tr></thead><tbody>
<tr><th scope="row">Server</th><td colSpan={2}><span className="mono">{info.host}</span> <button className="btn small" onClick={() => void copy('host', info.host)}>{copied === 'host' ? 'Kopiert ✓' : 'Kopieren'}</button></td></tr>
{info.alternativeHosts.length > 0 && <tr><th scope="row">Alternative Server</th><td colSpan={2} className="mono">{info.alternativeHosts.map((h) => <div key={h}>{h}</div>)}</td></tr>}
<tr><th scope="row">Benutzername</th><td colSpan={2}>{info.usernames.map((u) => <div key={u}><span className="mono">{u}</span> <button className="btn small" onClick={() => void copy(u, u)}>{copied === u ? 'Kopiert ✓' : 'Kopieren'}</button></div>)}</td></tr>
<tr><th scope="row">Passwort</th><td colSpan={2} className="small">Das Passwort des Postfachs (wird hier nicht angezeigt).</td></tr>
<tr><th scope="row">Port SSL/TLS (empfohlen)</th><td>{ports('IN', 'tls')}</td><td>{ports('SMTP', 'tls')}</td></tr>
<tr><th scope="row">Port STARTTLS</th><td>{ports('IN', 'starttls')}</td><td>{ports('SMTP', 'starttls')}</td></tr>
</tbody></table></div>
<p className="small muted">Postausgang: Anmeldung erforderlich, gleicher Benutzername und gleiches Passwort wie beim Posteingang.</p>
</>}
</div></div>);
}
export function HostingPanel({ resourceId, canLogin }: { resourceId: string; canLogin: boolean }) {
const [kinds, setKinds] = useState<Kinds | null>(null); const [kind, setKind] = useState<Kind>('domain'); const [rows, setRows] = useState<Child[] | null>(null); const [err, setErr] = useState('');
const [msg, setMsg] = useState<{ k: 'ok' | 'err' | 'info'; t: string } | null>(null); const [adding, setAdding] = useState(false); const [del, setDel] = useState<string | null>(null); const [busy, setBusy] = useState(false); const [pw, setPw] = useState('');
const [domains, setDomains] = useState<Child[]>([]);
const [domains, setDomains] = useState<Child[]>([]); const [conn, setConn] = useState<Child | null>(null);
useEffect(() => { api<Kinds>('GET', `/resources/${resourceId}/children`).then((k) => { setKinds(k); if (k.kinds[0]) setKind(k.kinds[0].kind); }).catch((e) => setErr(errMsg(e))); }, [resourceId]);
const load = useCallback(() => { setRows(null); setErr(''); api<Child[]>('GET', `/resources/${resourceId}/children/${kind}`).then(setRows).catch((e) => { setErr(errMsg(e)); setRows([]); }); }, [resourceId, kind]);
useEffect(() => { if (kinds) load(); }, [kinds, load]);
useEffect(() => { api<Child[]>('GET', `/resources/${resourceId}/children/domain`).then(setDomains).catch(() => setDomains([])); }, [resourceId]);
const canWrite = kinds?.kinds.find((k) => k.kind === kind)?.canWrite ?? false;
const canWrite = kinds?.kinds.find((k) => k.kind === kind)?.canWrite ?? false; const showConn = kind === 'email'; const closeConn = useCallback(() => setConn(null), []); const actions = canWrite || showConn;
async function submit(op: 'create' | 'update' | 'delete', data: Record<string, unknown>, opts: { id?: string; password?: string; okText: string }) {
setBusy(true); setMsg(null);
@ -92,7 +135,7 @@ export function HostingPanel({ resourceId, canLogin }: { resourceId: string; can
{kinds.kinds.map((k) => <button key={k.kind} role="tab" aria-selected={kind === k.kind} className="btn" style={kind === k.kind ? { background: 'var(--surface-2)', fontWeight: 600, borderColor: 'var(--accent)' } : undefined} onClick={() => { setKind(k.kind); setAdding(false); setMsg(null); setDel(null); }}>{LABEL[k.kind]}</button>)}</div>
{msg && <Alert kind={msg.k}>{msg.t}</Alert>}
{err && <Alert kind="err">{err}</Alert>}
{canWrite && kind !== 'certificate' && <div style={{ marginBottom: 12 }}><button className="btn primary" aria-expanded={adding} onClick={() => { setAdding(!adding); setPw(''); }}>{{ domain: 'Domain hinzufügen', email: 'Postfach anlegen', database: 'Datenbank anlegen', ftp: 'FTP-Zugang anlegen', certificate: '' }[kind]}</button></div>}
{canWrite && kind !== 'certificate' && <div style={{ marginBottom: 12 }}><button className="btn primary" aria-expanded={adding} onClick={() => { setAdding(!adding); setPw(''); }}>{{ domain: 'Domain hinzufügen', email: 'Postfach anlegen', database: 'Datenbank anlegen', ftp: 'FTP-Zugang anlegen', certificate: '', dns: '', dirprotect: '' }[kind]}</button></div>}
{adding && canWrite && <form onSubmit={create} style={{ borderBottom: '1px solid var(--border)', marginBottom: 16, paddingBottom: 8 }}>
{kind === 'domain' && <div className="cols"><Field id="hp-dom" label="Domainname"><input id="hp-dom" name="domain" required placeholder="beispiel.de oder www.beispiel.de" /></Field><Field id="hp-php" label="PHP-Version (leer = Standard)"><input id="hp-php" name="php" placeholder="z. B. 8.3" /></Field><label className="row" style={{ alignSelf: 'end', minHeight: 44 }}><input type="checkbox" name="le" defaultChecked style={{ width: 20, minHeight: 20 }} />Let’s Encrypt und HTTPS</label></div>}
{kind === 'email' && <><div className="cols"><Field id="hp-loc" label="Postfach"><input id="hp-loc" name="local" required placeholder="info" /></Field><Field id="hp-md" label="Domain"><select id="hp-md" name="mdomain" required>{domains.filter((d) => d.details.emailDomain || true).map((d) => <option key={d.id} value={d.name}>{d.name}</option>)}</select></Field><Field id="hp-sz" label="Größe in MB (optional)"><input id="hp-sz" name="size" type="number" min={0} /></Field></div><PasswordField id="hp-pw" value={pw} onChange={setPw} /></>}
@ -100,17 +143,20 @@ export function HostingPanel({ resourceId, canLogin }: { resourceId: string; can
{kind === 'ftp' && <><div className="cols"><Field id="hp-fu" label="Benutzername (optional, sonst automatisch)"><input id="hp-fu" name="user" pattern="[A-Za-z0-9._-]{1,32}" /></Field><Field id="hp-fh" label="Verzeichnis" hint="Beginnt mit /www/ oder /files"><input id="hp-fh" name="home" defaultValue="/www/" /></Field><Field id="hp-fd" label="Beschreibung"><input id="hp-fd" name="desc" maxLength={200} /></Field></div><PasswordField id="hp-pw" value={pw} onChange={setPw} /></>}
<div className="row"><button className="btn primary" type="submit" disabled={busy}>{busy ? 'Bitte warten …' : 'Anlegen'}</button><button className="btn" type="button" onClick={() => setAdding(false)}>Abbrechen</button></div></form>}
{rows === null ? <p className="muted" role="status">Wird beim Anbieter gelesen …</p> : rows.length === 0 && !err ? <Empty title="Keine Einträge" /> : (
<div className="tablewrap"><table><thead><tr><th>Name</th><th>Details</th><th>Status</th>{canWrite && <th><span className="sr">Aktionen</span></th>}</tr></thead><tbody>
<div className="tablewrap"><table><thead><tr><th>Name</th><th>Details</th><th>Status</th>{actions && <th><span className="sr">Aktionen</span></th>}</tr></thead><tbody>
{rows.map((r) => { const [c, i, l] = STATE[r.state] ?? ['info', '○', r.state]; const d = r.details; return (<tr key={r.id}>
<td className="mono">{r.name}</td>
<td className="small">{r.kind === 'domain' && <>{d.subdomain ? 'Subdomain' : d.system ? 'System-Domain' : 'Hauptdomain'} · PHP {d.phpVersion} · {d.letsEncrypt ? 'Let’s Encrypt' : 'kein Let’s Encrypt'}{d.forceHttps ? ' · HTTPS erzwungen' : ''}</>}
{r.kind === 'email' && <>{bytes(d.sizeBytes)} von {d.maxSizeBytes ? bytes(d.maxSizeBytes) : 'unbegrenzt'}{d.forwardings?.length ? ` · Weiterleitung an ${d.forwardings.join(', ')}` : ''}</>}
{r.kind === 'database' && <>Benutzer <span className="mono">{d.user}</span> · {bytes(d.sizeBytes)}</>}
{r.kind === 'ftp' && <>Verzeichnis <span className="mono">{d.home}</span></>}
{r.kind === 'certificate' && <>{d.issuer ?? '–'} · gültig bis {r.validUntil ? fmt(r.validUntil) : '–'} · {(d.securedDomains ?? []).join(', ')}</>}</td>
{r.kind === 'dns' && <><span className="mono">{d.type}</span> → <span className="mono">{d.value}</span>{d.ttl ? ` · TTL ${d.ttl}` : ''}</>}
{r.kind === 'dirprotect' && <>Benutzer <span className="mono">{d.username ?? '–'}</span>{d.realm ? ` · „${d.realm}“` : ''}{d.exceptions?.length ? ` · Ausnahmen: ${d.exceptions.join(', ')}` : ''}</>}
{r.kind === 'certificate' && <>{d.issuer ?? '–'} · gültig bis {r.validUntil ? fmtDate(r.validUntil) : '–'} · {(d.securedDomains ?? []).join(', ')}</>}</td>
<td><span className={`badge ${c}`}><span aria-hidden="true">{i}</span>{l}</span></td>
{canWrite && <td>{del === r.id ? <div role="alertdialog" aria-label="Löschen bestätigen"><p className="small" style={{ margin: '0 0 8px' }}><strong>„{r.name}“ endgültig löschen?</strong>{r.kind !== 'domain' ? ' Die Daten gehen verloren.' : ' Zugehörige Inhalte können verloren gehen.'}</p><div className="row"><button className="btn small danger" disabled={busy} onClick={() => submit('delete', {}, { id: r.id, okText: 'Wurde gelöscht.' })}>Ja, löschen</button><button className="btn small" onClick={() => setDel(null)}>Abbrechen</button></div></div>
: <div className="row" style={{ gap: 8 }}><button className="btn small danger" onClick={() => setDel(r.id)} disabled={busy || (r.kind === 'domain' && d.system)}>Löschen</button></div>}</td>}</tr>); })}</tbody></table></div>)}
{actions && <td>{canWrite && del === r.id ? <div role="alertdialog" aria-label="Löschen bestätigen"><p className="small" style={{ margin: '0 0 8px' }}><strong>„{r.name}“ endgültig löschen?</strong>{r.kind !== 'domain' ? ' Die Daten gehen verloren.' : ' Zugehörige Inhalte können verloren gehen.'}</p><div className="row"><button className="btn small danger" disabled={busy} onClick={() => submit('delete', {}, { id: r.id, okText: 'Wurde gelöscht.' })}>Ja, löschen</button><button className="btn small" onClick={() => setDel(null)}>Abbrechen</button></div></div>
: <div className="row" style={{ gap: 8 }}>{showConn && <button className="btn small" onClick={() => setConn(r)}>Verbindungsdaten</button>}{canWrite && <button className="btn small danger" onClick={() => setDel(r.id)} disabled={busy || (r.kind === 'domain' && d.system)}>Löschen</button>}</div>}</td>}</tr>); })}</tbody></table></div>)}
</div>
{conn && <ConnectionDialog resourceId={resourceId} child={conn} onClose={closeConn} />}
</>);
}

View file

@ -0,0 +1,34 @@
/** Einheitliche Strich-Icons (Pfade aus Lucide, ISC-Lizenz) statt Emojis. Immer dekorativ: Bedeutung trägt der Text daneben. */
const PATHS = {
home: <><path d="M3 10.5 12 3l9 7.5" /><path d="M5 9.5V21h14V9.5" /><path d="M10 21v-6h4v6" /></>,
server: <><rect x="3" y="3" width="18" height="7" rx="2" /><rect x="3" y="14" width="18" height="7" rx="2" /><path d="M7 6.5h.01M7 17.5h.01" /></>,
ticket: <><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z" /></>,
receipt: <><path d="M4 2v20l3-2 3 2 2-2 2 2 3-2 3 2V2l-3 2-3-2-2 2-2-2-3 2z" /><path d="M8 8h8M8 12h8M8 16h5" /></>,
menu: <><path d="M4 6h16M4 12h16M4 18h16" /></>,
sun: <><circle cx="12" cy="12" r="4" /><path d="M12 2v2M12 20v2M4.93 4.93l1.41 1.41M17.66 17.66l1.41 1.41M2 12h2M20 12h2M6.34 17.66l-1.41 1.41M19.07 4.93l-1.41 1.41" /></>,
moon: <><path d="M12 3a6 6 0 0 0 9 9 9 9 0 1 1-9-9Z" /></>,
monitor: <><rect x="2" y="3" width="20" height="14" rx="2" /><path d="M8 21h8M12 17v4" /></>,
eye: <><path d="M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7S2 12 2 12Z" /><circle cx="12" cy="12" r="3" /></>,
file: <><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" /><path d="M14 2v6h6" /></>,
key: <><circle cx="7.5" cy="15.5" r="5.5" /><path d="m21 2-9.6 9.6M15.5 7.5l3 3L22 7l-3-3" /></>,
fileText: <><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" /><path d="M14 2v6h6M16 13H8M16 17H8M10 9H8" /></>,
cart: <><circle cx="8" cy="21" r="1" /><circle cx="19" cy="21" r="1" /><path d="M2.05 2.05h2l2.66 12.42a2 2 0 0 0 2 1.58h9.78a2 2 0 0 0 1.95-1.57l1.65-7.43H5.12" /></>,
inbox: <><path d="M22 12h-6l-2 3h-4l-2-3H2" /><path d="M5.45 5.11 2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z" /></>,
building: <><rect x="4" y="2" width="16" height="20" rx="2" /><path d="M9 22v-4h6v4M8 6h.01M16 6h.01M12 6h.01M12 10h.01M12 14h.01M16 10h.01M16 14h.01M8 10h.01M8 14h.01" /></>,
globe: <><circle cx="12" cy="12" r="10" /><path d="M2 12h20M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z" /></>,
users: <><path d="M16 21v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2" /><circle cx="9" cy="7" r="4" /><path d="M22 21v-2a4 4 0 0 0-3-3.87M16 3.13a4 4 0 0 1 0 7.75" /></>,
package: <><path d="m7.5 4.27 9 5.15M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z" /><path d="m3.3 7 8.7 5 8.7-5M12 22V12" /></>,
list: <><path d="M8 6h13M8 12h13M8 18h13M3 6h.01M3 12h.01M3 18h.01" /></>,
userCog: <><circle cx="10" cy="7" r="4" /><path d="M10.3 15H7a4 4 0 0 0-4 4v2" /><circle cx="18" cy="18" r="3" /><path d="M18 13.5V15M18 21v1.5M22.5 18H21M15 18h-1.5" /></>,
activity: <><path d="M22 12h-4l-3 9L9 3l-3 9H2" /></>,
shield: <><path d="M20 13c0 5-3.5 7.5-7.66 8.95a1 1 0 0 1-.67-.01C7.5 20.5 4 18 4 13V6a1 1 0 0 1 1-1c2 0 4.5-1.2 6.24-2.72a1.17 1.17 0 0 1 1.52 0C14.51 3.81 17 5 19 5a1 1 0 0 1 1 1z" /></>,
settings: <><path d="M12.22 2h-.44a2 2 0 0 0-2 2v.18a2 2 0 0 1-1 1.73l-.43.25a2 2 0 0 1-2 0l-.15-.08a2 2 0 0 0-2.73.73l-.22.38a2 2 0 0 0 .73 2.73l.15.1a2 2 0 0 1 1 1.72v.51a2 2 0 0 1-1 1.74l-.15.09a2 2 0 0 0-.73 2.73l.22.38a2 2 0 0 0 2.73.73l.15-.08a2 2 0 0 1 2 0l.43.25a2 2 0 0 1 1 1.73V20a2 2 0 0 0 2 2h.44a2 2 0 0 0 2-2v-.18a2 2 0 0 1 1-1.73l.43-.25a2 2 0 0 1 2 0l.15.08a2 2 0 0 0 2.73-.73l.22-.39a2 2 0 0 0-.73-2.73l-.15-.08a2 2 0 0 1-1-1.74v-.5a2 2 0 0 1 1-1.74l.15-.09a2 2 0 0 0 .73-2.73l-.22-.38a2 2 0 0 0-2.73-.73l-.15.08a2 2 0 0 1-2 0l-.43-.25a2 2 0 0 1-1-1.73V4a2 2 0 0 0-2-2z" /><circle cx="12" cy="12" r="3" /></>,
user: <><circle cx="12" cy="8" r="5" /><path d="M20 21a8 8 0 0 0-16 0" /></>,
logout: <><path d="M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4M16 17l5-5-5-5M21 12H9" /></>,
chevron: <><path d="m9 18 6-6-6-6" /></>,
} as const;
export type IconName = keyof typeof PATHS;
export function Icon({ name, className = 'icon' }: { name: IconName; className?: string }) {
return <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth={2} strokeLinecap="round" strokeLinejoin="round" aria-hidden="true" focusable="false">{PATHS[name]}</svg>;
}

View file

@ -3,7 +3,7 @@ import { useCallback, useEffect, useState, type FormEvent } from 'react';
import Link from 'next/link';
import { api, errMsg } from '@/lib/api';
import { useSession } from '@/lib/session';
import { Alert, Empty, Field, InvoiceStatusBadge, eur, fmt } from '@/components/ui';
import { Alert, Empty, Field, InvoiceStatusBadge, eur, fmt, fmtDay } from '@/components/ui';
interface Inv { id: string; number: string | null; orgId: string; orgName: string; customerNumber: string; status: string; overdue: boolean; issueDate: string | null; dueDate: string | null; totalGrossCents: number; createdAt: string }
interface Cust { id: string; name: string; customerNumber: string }
@ -35,7 +35,7 @@ export function InvoiceList({ orgId }: { orgId?: string }) {
{list === null ? <p className="muted" role="status">Wird geladen …</p> : list.length === 0 ? <Empty title="Keine Rechnungen" /> :
<div className="tablewrap"><table><thead><tr><th>Nr.</th>{!orgId && <th>Kunde</th>}<th>Status</th><th>Datum</th><th>Fällig</th><th>Betrag</th></tr></thead><tbody>
{list.map((i) => (<tr key={i.id}><td className="mono"><Link href={`/rechnungen/${i.id}`}>{i.number ?? 'Entwurf'}</Link></td>{!orgId && <td>{i.orgName}</td>}
<td><InvoiceStatusBadge value={i.status} overdue={i.overdue} /></td><td className="small">{i.issueDate ? fmt(i.issueDate) : '–'}</td><td className="small">{i.dueDate ? fmt(i.dueDate) : '–'}</td><td>{eur(i.totalGrossCents)}</td></tr>))}
<td><InvoiceStatusBadge value={i.status} overdue={i.overdue} /></td><td className="small">{i.issueDate ? fmtDay(i.issueDate) : '–'}</td><td className="small">{i.dueDate ? fmtDay(i.dueDate) : '–'}</td><td>{eur(i.totalGrossCents)}</td></tr>))}
</tbody></table></div>}
</div>
</>);

View file

@ -0,0 +1,28 @@
'use client';
import { useEffect } from 'react';
import { usePathname } from 'next/navigation';
/** Beschriftet Tabellenzellen mit ihrer Spaltenüberschrift (data-label), damit Tabellen auf schmalen Bildschirmen
* als Karten erscheinen können (siehe .tablewrap in globals.css). Beobachtet nachgeladene Zeilen. */
export function TableCards() {
const path = usePathname();
useEffect(() => {
const main = document.getElementById('main'); if (!main) return;
const label = () => main.querySelectorAll<HTMLTableElement>('.tablewrap table').forEach((t) => {
const heads = [...t.querySelectorAll('thead th')].map((th) => th.textContent?.trim() ?? '');
t.querySelectorAll('tbody tr').forEach((tr) => {
let col = 0;
for (const cell of tr.children) {
const span = (cell as HTMLTableCellElement).colSpan || 1; const l = span === 1 ? heads[col] : '';
if (l) { if (cell.getAttribute('data-label') !== l) cell.setAttribute('data-label', l); } else cell.removeAttribute('data-label');
col += span;
}
});
});
label();
// nur childList beobachten: das Setzen der Attribute löst so keine weitere Runde aus
const mo = new MutationObserver(label); mo.observe(main, { childList: true, subtree: true });
return () => mo.disconnect();
}, [path]);
return null;
}

View file

@ -1,10 +1,11 @@
'use client';
import { useEffect, useState } from 'react';
import { Icon, type IconName } from '@/components/Icon';
type Theme = 'light' | 'dark' | 'system';
const KEY = 'kc-theme';
const LABEL: Record<Theme, string> = { system: 'System', light: 'Hell', dark: 'Dunkel' };
const ICON: Record<Theme, string> = { system: '🌓', light: '☀️', dark: '🌙' };
const ICON: Record<Theme, IconName> = { system: 'monitor', light: 'sun', dark: 'moon' };
const NEXT: Record<Theme, Theme> = { system: 'light', light: 'dark', dark: 'system' };
function apply(t: Theme) {
@ -24,7 +25,7 @@ export function ThemeToggle({ compact = false }: { compact?: boolean }) {
}
return (
<button type="button" className="btn small" onClick={cycle} title={`Darstellung: ${LABEL[theme]}. Klicken zum Wechseln.`} aria-label={`Darstellung: ${LABEL[theme]}. Klicken zum Wechseln.`}>
<span aria-hidden="true">{ICON[theme]}</span>{!compact && <> {LABEL[theme]}</>}
<Icon name={ICON[theme]} />{!compact && <> {LABEL[theme]}</>}
</button>
);
}

View file

@ -1,4 +1,4 @@
import type { ReactNode } from 'react';
import { cloneElement, isValidElement, type ReactElement, type ReactNode } from 'react';
/** Einheitliches Statussystem: Text + Symbol, nie nur Farbe. */
const MAP: Record<string, { cls: string; icon: string; label: string }> = {
@ -11,12 +11,19 @@ export function Status({ value }: { value: string }) {
return <span className={`badge ${m.cls}`}><span aria-hidden="true">{m.icon}</span>{m.label}</span>;
}
export const Alert = ({ kind, children }: { kind: 'err' | 'ok' | 'warn' | 'info'; children: ReactNode }) => <div className={`alert ${kind}`} role={kind === 'err' ? 'alert' : 'status'}>{children}</div>;
/** Formularfeld: sichtbares, verknüpftes Label; ein Hinweis wird per aria-describedby an das Eingabeelement gebunden. */
export const Field = ({ id, label, children, hint }: { id: string; label: string; children: ReactNode; hint?: string }) => (
<div className="field"><label htmlFor={id}>{label}</label>{children}{hint && <span className="muted small">{hint}</span>}</div>
<div className="field"><label htmlFor={id}>{label}</label>
{hint && isValidElement(children) ? cloneElement(children as ReactElement<{ 'aria-describedby'?: string }>, { 'aria-describedby': `${id}-hint` }) : children}
{hint && <span id={`${id}-hint`} className="muted small">{hint}</span>}</div>
);
export const Empty = ({ title, children }: { title: string; children?: ReactNode }) => <div className="empty"><h3>{title}</h3>{children}</div>;
export const fmt = (d: string | Date) => new Date(d).toLocaleString('de-DE', { dateStyle: 'medium', timeStyle: 'short' });
export const ROLE_LABEL: Record<string, string> = { support: 'Support', accounting: 'Buchhaltung', admin: 'Administrator', superadmin: 'Superadministrator', owner: 'Inhaber', member: 'Mitglied' };
/** Zeitpunkt nur als Datum (Laufzeitende, Gültigkeit) – in der Ortszeit des Betrachters. */
export const fmtDate = (d: string | Date) => new Date(d).toLocaleDateString('de-DE', { dateStyle: 'medium' });
/** Reine Datumsspalte (SQL DATE, kommt als UTC-Mitternacht) – ohne Zeitzonenverschiebung. */
export const fmtDay = (d: string | Date) => new Date(d).toLocaleDateString('de-DE', { dateStyle: 'medium', timeZone: 'UTC' });
export const ROLE_LABEL: Record<string, string> = { support: 'Support', accounting: 'Buchhaltung', admin: 'Administrator', superadmin: 'Superadministrator', management: 'Management (nur Auswertung)', owner: 'Inhaber', member: 'Mitglied' };
export const STATE: Record<string, { cls: string; icon: string; label: string }> = {
active: { cls: 'ok', icon: '●', label: 'Aktiv' }, suspended: { cls: 'lock', icon: '⊘', label: 'Gesperrt' }, expired: { cls: 'warn', icon: '▲', label: 'Abgelaufen' },

8
apps/web/src/lib/csv.ts Normal file
View file

@ -0,0 +1,8 @@
/**
* CSV-Zellen für den Excel-Export im Browser. Gleiche Regel wie @kc/platform/csv (dort getestet): Textzellen, die mit
* = + - @ Tab oder CR beginnen, bekommen ein führendes Apostroph, damit Excel sie nicht als Formel ausführt.
* Zahlenzellen (Beträge) nur quotieren, nicht neutralisieren – sonst würde aus "-1,50" Text.
*/
const quote = (s: string) => `"${s.replace(/"/g, '""')}"`;
export const csvText = (v: string | null | undefined): string => { const s = v ?? ''; return quote(/^[=+\-@\t\r]/.test(s) ? `'${s}` : s); };
export const csvValue = (v: string | number | null | undefined): string => quote(String(v ?? ''));

View file

@ -1,6 +1,8 @@
import { ChannelType, Client, GatewayIntentBits, OverwriteType, PermissionFlagsBits, REST, Routes, SlashCommandBuilder, type ChatInputCommandInteraction, type Guild, type Message, type OverwriteResolvable, type TextChannel } from 'discord.js';
import { randomUUID } from 'node:crypto';
import { pool } from '@kc/platform/db';
import { pool, run, tx } from '@kc/platform/db';
import { nextSequence } from '@kc/platform/sequences';
import { staffMayTicket } from '@kc/platform/ticketPolicy';
import { decrypt } from '@kc/platform/crypto';
import { enqueue } from '@kc/platform/jobs';
import { config } from '@kc/platform/config';
@ -23,13 +25,25 @@ async function loadSettings(): Promise<DiscordSettings> {
};
}
const notify = (event: string, extra: Record<string, unknown>, key: string) => enqueue('discord.notify', { event, ...extra }, { idempotencyKey: key });
async function nextTicketNumber(): Promise<string> {
await pool.query("UPDATE number_sequences SET next_value = LAST_INSERT_ID(next_value + 1) WHERE name = 'ticket'");
const [r] = await pool.query('SELECT LAST_INSERT_ID() AS n') as any;
return `T-${r[0].n}`;
/** Legt Ticket + erste Nachricht in EINER Transaktion an; die Nummer kommt über dieselbe Verbindung (LAST_INSERT_ID). */
async function createTicket(t: { orgId: string; subject: string; status: string; createdBy: string; authorKind: 'customer' | 'staff'; body: string }): Promise<{ id: string; number: string }> {
const id = randomUUID();
const number = await tx(async (c) => {
const n = `T-${await nextSequence(c, 'ticket')}`;
await run('INSERT INTO tickets (id, number, org_id, subject, status, priority, created_by) VALUES (?,?,?,?,?,?,?)', [id, n, t.orgId, t.subject, t.status, 'normal', t.createdBy], c);
await run('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), id, t.createdBy, t.authorKind, t.body], c);
return n;
});
return { id, number };
}
const linkedUser = (discordUserId: string, kind: 'customer' | 'staff') =>
pool.query("SELECT id, name FROM users WHERE discord_user_id = ? AND kind = ? AND status = 'active'", [discordUserId, kind]).then(([r]: any) => r[0]);
const linkedCustomer = (discordUserId: string) =>
pool.query("SELECT id, name FROM users WHERE discord_user_id = ? AND kind = 'customer' AND status = 'active'", [discordUserId]).then(([r]: any) => r[0] as { id: string; name: string } | undefined);
/** Verknüpftes, aktives Personal-Konto MIT dem nötigen Ticket-Recht der zentralen Policy (Buchhaltung: nur lesen). */
const linkedStaff = async (discordUserId: string, permission: 'tickets.read' | 'tickets.write' = 'tickets.write') => {
const u = await pool.query("SELECT id, name, staff_role FROM users WHERE discord_user_id = ? AND kind = 'staff' AND status = 'active'", [discordUserId]).then(([r]: any) => r[0] as { id: string; name: string; staff_role: string | null } | undefined);
return u && staffMayTicket(u.staff_role, permission) ? u : undefined;
};
const NO_STAFF = 'Nur für verknüpfte Personal-Konten mit Schreibrecht für Tickets.';
const ticketForThread = (channelId: string) =>
pool.query('SELECT tt.ticket_id, tk.number FROM ticket_discord_threads tt JOIN tickets tk ON tk.id = tt.ticket_id WHERE tt.thread_id = ?', [channelId]).then(([r]: any) => r[0]);
@ -63,15 +77,13 @@ async function handleTicketCreate(i: ChatInputCommandInteraction): Promise<void>
const body = i.options.getString('text', true).slice(0, 2000);
const kunde = i.options.getString('kunde')?.trim();
const customer = await linkedUser(i.user.id, 'customer');
const customer = await linkedCustomer(i.user.id);
if (customer) {
const mem = await pool.query("SELECT org_id FROM memberships WHERE user_id = ? ORDER BY (role = 'owner') DESC LIMIT 1", [customer.id]).then(([r]: any) => r[0]);
if (!mem) { await i.reply({ content: 'Für dein Konto ist keine Organisation hinterlegt.', ephemeral: true }); return; }
// nur aktive Organisationen (gesperrte Kunden eröffnen keine Tickets per Discord)
const mem = await pool.query("SELECT m.org_id FROM memberships m JOIN organizations o ON o.id = m.org_id AND o.status = 'active' WHERE m.user_id = ? ORDER BY (m.role = 'owner') DESC LIMIT 1", [customer.id]).then(([r]: any) => r[0]);
if (!mem) { await i.reply({ content: 'Für dein Konto ist keine aktive Organisation hinterlegt.', ephemeral: true }); return; }
await i.deferReply({ ephemeral: true });
const ticketId = randomUUID();
const number = await nextTicketNumber();
await pool.query('INSERT INTO tickets (id, number, org_id, subject, status, priority, created_by) VALUES (?,?,?,?,?,?,?)', [ticketId, number, mem.org_id, subject, 'pending_staff', 'normal', customer.id]);
await pool.query('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), ticketId, customer.id, 'customer', body]);
const { id: ticketId, number } = await createTicket({ orgId: mem.org_id, subject, status: 'pending_staff', createdBy: customer.id, authorKind: 'customer', body });
await notify('ticket.created', { number, subject: subject.slice(0, 100) }, `discord-cmd:${ticketId}`);
await postTicketMessage(ticketId, body, 'Kunde');
const ch = await ticketChannelId(ticketId);
@ -79,8 +91,8 @@ async function handleTicketCreate(i: ChatInputCommandInteraction): Promise<void>
return;
}
const staff = await linkedUser(i.user.id, 'staff');
if (!staff) { await i.reply({ content: 'Dein Discord-Konto ist mit keinem Kundencenter-Konto verknüpft (unter „Mein Konto“ → „Mit Discord verbinden“).', ephemeral: true }); return; }
const staff = await linkedStaff(i.user.id);
if (!staff) { await i.reply({ content: 'Dein Discord-Konto ist mit keinem Kundencenter-Konto mit Ticket-Schreibrecht verknüpft (unter „Mein Konto“ → „Mit Discord verbinden“).', ephemeral: true }); return; }
if (!kunde) { await i.reply({ content: 'Als Personal bitte die Option „kunde“ angeben (Kundennummer oder Name), für wen das Ticket ist.', ephemeral: true }); return; }
const orgs = await pool.query("SELECT id, name, customer_number FROM organizations WHERE customer_number = ? OR name LIKE CONCAT('%', ?, '%') LIMIT 2", [kunde, kunde]) as [any[], unknown];
const matches = orgs[0];
@ -88,29 +100,26 @@ async function handleTicketCreate(i: ChatInputCommandInteraction): Promise<void>
if (matches.length > 1) { await i.reply({ content: `Mehrdeutig – bitte die genaue Kundennummer angeben (z. B. gefunden: ${matches.map((m) => m.customer_number).join(', ')}).`, ephemeral: true }); return; }
const org = matches[0];
await i.deferReply({ ephemeral: true });
const ticketId = randomUUID();
const number = await nextTicketNumber();
// Von Personal angelegt: wartet auf den Kunden, wie beim Anlegen über die Web-Oberfläche.
await pool.query('INSERT INTO tickets (id, number, org_id, subject, status, priority, created_by) VALUES (?,?,?,?,?,?,?)', [ticketId, number, org.id, subject, 'pending_customer', 'normal', staff.id]);
await pool.query('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), ticketId, staff.id, 'staff', body]);
const { id: ticketId, number } = await createTicket({ orgId: org.id, subject, status: 'pending_customer', createdBy: staff.id, authorKind: 'staff', body });
await postTicketMessage(ticketId, body, 'Support');
const ch = await ticketChannelId(ticketId);
await i.editReply({ content: `Ticket ${number} für ${org.name} (${org.customer_number}) wurde angelegt.${ch ? ` <#${ch}>` : ''}` });
}
/** Weist das Ticket des aktuellen Threads einer per Discord verknüpften Personal-Person zu. */
async function handleAssign(i: ChatInputCommandInteraction): Promise<void> {
if (!(await linkedUser(i.user.id, 'staff'))) { await i.reply({ content: 'Nur für verknüpfte Personal-Konten.', ephemeral: true }); return; }
if (!(await linkedStaff(i.user.id))) { await i.reply({ content: NO_STAFF, ephemeral: true }); return; }
const t = await ticketForThread(i.channelId);
if (!t) { await i.reply({ content: 'Dieser Befehl funktioniert nur innerhalb eines Ticket-Threads.', ephemeral: true }); return; }
const target = i.options.getUser('mitarbeiter', true);
const assignee = await linkedUser(target.id, 'staff');
const assignee = await linkedStaff(target.id); // nur wer im Web Tickets bearbeiten darf, kann sie auch zugewiesen bekommen
if (!assignee) { await i.reply({ content: `${target.username} hat kein verknüpftes Personal-Konto.`, ephemeral: true }); return; }
await pool.query('UPDATE tickets SET assigned_to = ? WHERE id = ?', [assignee.id, t.ticket_id]);
await i.reply({ content: `Ticket ${t.number} wurde ${assignee.name} zugewiesen.` });
}
/** Schließt das Ticket des aktuellen Threads. */
async function handleClose(i: ChatInputCommandInteraction): Promise<void> {
if (!(await linkedUser(i.user.id, 'staff'))) { await i.reply({ content: 'Nur für verknüpfte Personal-Konten.', ephemeral: true }); return; }
if (!(await linkedStaff(i.user.id))) { await i.reply({ content: NO_STAFF, ephemeral: true }); return; }
const t = await ticketForThread(i.channelId);
if (!t) { await i.reply({ content: 'Dieser Befehl funktioniert nur innerhalb eines Ticket-Threads.', ephemeral: true }); return; }
await pool.query("UPDATE tickets SET status = 'closed', closed_at = UTC_TIMESTAMP(3) WHERE id = ?", [t.ticket_id]);
@ -123,7 +132,7 @@ async function handle(i: ChatInputCommandInteraction): Promise<void> {
if (i.commandName === 'zuweisen') return handleAssign(i);
if (i.commandName === 'schliessen') return handleClose(i);
// Alle Antworten ephemeral: nie vertrauliche Daten in Kanälen sichtbar machen. Berechtigung = verknüpftes Personal-Konto (wie /zuweisen, /schliessen).
if (!(await linkedUser(i.user.id, 'staff'))) { await i.reply({ content: 'Nur für verknüpfte Personal-Konten.', ephemeral: true }); return; }
if (!(await linkedStaff(i.user.id, 'tickets.read'))) { await i.reply({ content: 'Nur für verknüpfte Personal-Konten.', ephemeral: true }); return; }
if (i.commandName === 'kc-status') {
const [rows] = await pool.query('SELECT status, COUNT(*) n FROM jobs GROUP BY status') as any;
const jobs = rows.length ? rows.map((r: any) => `${r.status}: ${r.n}`).join(', ') : 'keine';
@ -137,27 +146,31 @@ async function handle(i: ChatInputCommandInteraction): Promise<void> {
/** Nachricht im Ticket-Thread bzw. Ticket-Kanal übernehmen: vom Kunden als Kundenantwort, vom Personal (verknüpftes Konto)
* als Support-Antwort wie im Kundencenter (Status "wartet auf Kunde", Mail an den Ersteller). Andere Nachrichten werden ignoriert. */
async function handleThreadMessage(msg: Message, log: (m: string) => void): Promise<void> {
/** Exportiert für Worker-Tests (nachgebaute Discord-Nachrichten). */
export async function handleThreadMessage(msg: Message, log: (m: string) => void): Promise<void> {
if (msg.author.bot || !msg.inGuild()) return;
const t = await pool.query('SELECT tt.ticket_id, tk.number, tk.subject, tk.org_id, tk.status, tk.created_by FROM ticket_discord_threads tt JOIN tickets tk ON tk.id = tt.ticket_id WHERE tt.thread_id = ?', [msg.channel.id]).then(([r]: any) => r[0]);
if (!t) return;
if (t.status === 'closed') { await msg.reply('Dieses Ticket ist geschlossen. Bitte im Kundencenter ein neues Ticket eröffnen oder den Befehl `/ticket` nutzen.').catch(() => undefined); return; }
const body = msg.content.trim().slice(0, 10000);
if (!body) return;
const staff = await linkedUser(msg.author.id, 'staff');
const staffAny = await linkedStaff(msg.author.id, 'tickets.read');
const staff = staffAny && staffMayTicket(staffAny.staff_role, 'tickets.write') ? staffAny : undefined;
if (staffAny && !staff) { await msg.reply('Dein Konto darf Tickets nur lesen – die Nachricht wurde nicht ins Ticket übernommen.').catch(() => undefined); return; }
if (staff) {
await pool.query('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), t.ticket_id, staff.id, 'staff', body]);
await pool.query("UPDATE tickets SET status = 'pending_customer', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [t.ticket_id]);
await audit({ actorType: 'user', actorId: staff.id, orgId: t.org_id, action: 'ticket.message', resourceType: 'ticket', resourceId: t.ticket_id, after: { internalNote: false, via: 'discord' } });
const creator = await pool.query('SELECT email, name FROM users WHERE id = ?', [t.created_by]).then(([r]: any) => r[0]);
if (creator) await enqueue('mail.template', { to: creator.email, key: 'ticket_message', vars: { name: creator.name, number: t.number, subject: t.subject, ticketLink: ticketLink(t.ticket_id) } }, { idempotencyKey: `mail:discord-staff:${msg.id}` });
if (creator) await enqueue('mail.template', { to: creator.email, key: 'ticket_message', vars: { name: creator.name, number: t.number, subject: t.subject, ticketLink: ticketLink(t.ticket_id) }, replyTicketId: t.ticket_id }, { idempotencyKey: `mail:discord-staff:${msg.id}` });
log(`Discord: Support-Antwort zu Ticket ${t.number} übernommen.`);
return;
}
const u = await pool.query("SELECT id, name FROM users WHERE discord_user_id = ? AND kind = 'customer'", [msg.author.id]).then(([r]: any) => r[0]);
if (!u) return; // Discord-Konto ohne Verknüpfung: nicht zuordenbar
const member = await pool.query('SELECT 1 AS x FROM memberships WHERE user_id = ? AND org_id = ?', [u.id, t.org_id]).then(([r]: any) => r[0]);
const u = await linkedCustomer(msg.author.id); // nur aktive Konten
if (!u) return; // Discord-Konto ohne (aktive) Verknüpfung: nicht zuordenbar
const member = await pool.query('SELECT o.status FROM memberships m JOIN organizations o ON o.id = m.org_id WHERE m.user_id = ? AND m.org_id = ?', [u.id, t.org_id]).then(([r]: any) => r[0]);
if (!member) return;
if (member.status !== 'active') { await msg.reply('Dieses Kundenkonto ist derzeit gesperrt – die Nachricht wurde nicht übernommen.').catch(() => undefined); return; }
await pool.query('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), t.ticket_id, u.id, 'customer', body]);
await pool.query("UPDATE tickets SET status = 'pending_staff', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [t.ticket_id]);
await notify('ticket.message', { number: t.number }, `discord-in:${msg.id}`);
@ -172,7 +185,7 @@ const BOT_PERMS = [...CHANNEL_PERMS, PermissionFlagsBits.ManageChannels];
const slug = (v: string) => v.toLowerCase().replace(/ä/g, 'ae').replace(/ö/g, 'oe').replace(/ü/g, 'ue').replace(/ß/g, 'ss').replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
const ticketLink = (id: string) => `${config.baseUrl}/tickets/${id}`;
/** Discord-Konten der Kunden-Mitglieder (nur verknüpfte, aktive Benutzer der Organisation). */
const orgDiscordIds = (orgId: string) => pool.query("SELECT u.discord_user_id FROM memberships m JOIN users u ON u.id = m.user_id WHERE m.org_id = ? AND u.kind = 'customer' AND u.status = 'active' AND u.discord_user_id IS NOT NULL", [orgId])
const orgDiscordIds = (orgId: string) => pool.query("SELECT u.discord_user_id FROM memberships m JOIN users u ON u.id = m.user_id JOIN organizations o ON o.id = m.org_id AND o.status = 'active' WHERE m.org_id = ? AND u.kind = 'customer' AND u.status = 'active' AND u.discord_user_id IS NOT NULL", [orgId])
.then(([r]: any) => (r as { discord_user_id: string }[]).map((x) => x.discord_user_id));
function overwrites(guild: Guild, s: DiscordSettings, customerIds: string[]): OverwriteResolvable[] {
return [
@ -222,11 +235,18 @@ async function ensureTicketChannel(s: DiscordSettings, ticketId: string, withOpe
return { channel, created: true };
});
}
/** Ergänzt Kunden-Mitglieder, die ihr Discord erst nach dem Anlegen des Kanals verknüpft haben (nur wenn etwas fehlt). */
async function grantCustomers(channel: TextChannel, orgId: string): Promise<void> {
for (const id of await orgDiscordIds(orgId)) {
/** Gleicht die Kunden-Freigaben des Kanals mit den aktuell berechtigten Mitgliedern ab: ergänzt neu verknüpfte und
* ENTFERNT Freigaben von Konten, die entknüpft, deaktiviert, aus der Organisation entfernt oder deren Kunde gesperrt
* ist. Rollen-Freigaben (Support) und der Bot bleiben unberührt. */
async function syncCustomerAccess(channel: TextChannel, orgId: string): Promise<void> {
const wanted = new Set(await orgDiscordIds(orgId));
const botId = channel.client.user.id;
for (const id of wanted) {
if (!channel.permissionOverwrites.cache.has(id)) await channel.permissionOverwrites.create(id, { ViewChannel: true, SendMessages: true, ReadMessageHistory: true, AttachFiles: true }, { type: OverwriteType.Member, reason: 'Kunde hat Discord verknüpft' });
}
for (const ow of [...channel.permissionOverwrites.cache.values()]) {
if (ow.type === OverwriteType.Member && ow.id !== botId && !wanted.has(ow.id)) await ow.delete('Kein Zugriff mehr (Verknüpfung getrennt, Konto/Kunde gesperrt oder nicht mehr Mitglied)');
}
}
/** Abgleich (minütlich): Kanäle für offene Tickets anlegen, Kanäle geschlossener Tickets löschen, Support-Meldekanal anlegen. */
export async function reconcileTicketChannels(log: (m: string) => void): Promise<void> {
@ -256,7 +276,7 @@ export async function reconcileTicketChannels(log: (m: string) => void): Promise
const [open] = await pool.query("SELECT tk.id, tk.org_id, tt.thread_id FROM tickets tk LEFT JOIN ticket_discord_threads tt ON tt.ticket_id = tk.id WHERE tk.status <> 'closed' AND (tt.thread_id IS NOT NULL OR tk.created_at < DATE_SUB(UTC_TIMESTAMP(3), INTERVAL 2 MINUTE))") as any;
for (const r of open) {
const res = await ensureTicketChannel(s, r.id, true);
if (res && !res.created) await grantCustomers(res.channel, r.org_id);
if (res && !res.created) await syncCustomerAccess(res.channel, r.org_id);
}
}
/** Nachricht ins Ticket in Discord übernehmen. Kategorie-Modus: Kanal je Ticket (legt ihn bei Bedarf an).
@ -268,7 +288,7 @@ export async function postTicketMessage(ticketId: string, body: string, authorLa
const res = await ensureTicketChannel(s, ticketId, false);
if (!res) return; // Ticket geschlossen oder unbekannt
const t = await pool.query('SELECT org_id FROM tickets WHERE id = ?', [ticketId]).then(([r]: any) => r[0]);
if (t && !res.created) await grantCustomers(res.channel, t.org_id);
if (t && !res.created) await syncCustomerAccess(res.channel, t.org_id);
await res.channel.send({ content: `**${authorLabel}:** ${body}`.slice(0, 2000), allowedMentions: { parse: [] } });
return;
}

View file

@ -49,11 +49,30 @@ setInterval(() => void checkBackup(), 3600_000);
// Fehlschlag, solange kein Programm-Key/Lizenzschlüssel hinterlegt ist (siehe LicenseCheckError) - dann
// einfach weiter versuchen, keine Alarmierung (Betreiber hat die Lizenzierung schlicht noch nicht eingerichtet).
import { checkLicenseNow, LicenseCheckError } from '@kc/platform/license';
// Ausfall des Lizenzservers (outage) wird alle 10 Minuten erneut versucht und nach 30 Minuten gemeldet (siehe
// Betriebsalarme unten); Konfigurationsfehler/Ablehnungen werden ebenfalls gemeldet, aber nicht im Takt wiederholt.
let licenseOutage = false;
const checkLicense = async () => {
try { await checkLicenseNow(); }
catch (e) { if (!(e instanceof LicenseCheckError)) log(`Lizenzprüfung fehlgeschlagen: ${(e as Error).message}`); }
try { await checkLicenseNow(); licenseOutage = false; }
catch (e) {
licenseOutage = e instanceof LicenseCheckError && e.kind === 'outage';
const quiet = e instanceof LicenseCheckError && e.kind === 'config'; // z. B. noch kein Schlüssel hinterlegt (Testmodus)
if (!quiet) log(`Lizenzprüfung fehlgeschlagen: ${(e as Error).message}`);
}
};
setInterval(() => void checkLicense(), 12 * 3600_000); void checkLicense();
setInterval(() => { if (licenseOutage) void checkLicense(); }, 10 * 60_000);
// Betriebsalarme mit Entwarnung (#20/#38): Lizenzserver, Warteschlangen-Stau, Aufträge zur Prüfung → Discord-Meldung.
// Der Zustand ist zusätzlich im Dashboard sichtbar. Den Ausfall dieses Workers selbst meldet die API (Herzschlag).
import { applyConditions, heartbeat, workerConditions } from '@kc/platform/monitor';
const monitor = async () => {
try {
await heartbeat('worker');
await applyConditions(await workerConditions(), (key, kind, detail) => enqueue('discord.notify', { event: 'system.alert', key, kind, detail }, { idempotencyKey: `system.alert:${key}:${kind}:${Date.now()}` }));
} catch (e) { log(`Betriebsalarme: Prüfung fehlgeschlagen: ${(e as Error).message}`); }
};
setInterval(() => void monitor(), 60_000); void monitor();
// Vertrags-Erinnerung: ~30 Tage vor Laufzeitende Mail mit "Behalten"/"Kündigen"-Link (einmal je Vertrag,
// markiert über renewal_reminder_sent_at). Unabhängig von processContractLifecycle oben, die nur zum
@ -78,6 +97,17 @@ const purgeAudit = async () => {
};
setInterval(() => void purgeAudit(), 24 * 3600_000); void purgeAudit();
// Abrechnungslauf (#50): nur wenn unter Einstellungen > Firma eingeschaltet; erzeugt ausschließlich Entwürfe.
import { autoBillingEnabled, runBilling } from '@kc/platform/billing';
const billing = async () => {
try {
if (!(await autoBillingEnabled())) return;
const r = await runBilling(null);
if (r.drafts.length) log(`Abrechnungslauf: ${r.drafts.length} Entwürfe mit ${r.drafts.reduce((n, d) => n + d.items, 0)} Positionen angelegt`);
} catch (e) { log(`Abrechnungslauf fehlgeschlagen: ${(e as Error).message}`); }
};
setInterval(() => void billing(), 6 * 3600_000); void billing();
// Ticket-Posteingang: eingehende Mails abrufen und zuordnen (siehe mailbox.ts)
setInterval(() => void checkMailbox(log).catch((e) => log(`IMAP-Lauf fehlgeschlagen: ${(e as Error).message}`)), 120_000);
void checkMailbox(log).catch((e) => log(`IMAP-Lauf fehlgeschlagen: ${(e as Error).message}`));

View file

@ -4,7 +4,8 @@ import { pool } from '@kc/platform/db';
import { notifyAdmin, postTicketMessage } from './discord.js';
import { JobFailure } from '@kc/platform/jobs';
import { sendTemplateMail } from '@kc/platform/mail';
import { executeAction, executeChild, provisionOrder, syncInstance, type ChildPayload, type ExecutePayload } from '@kc/connectors';
import { alertText } from '@kc/platform/monitor';
import { executeAction, executeChild, provisionOrder, syncCustomerInfo, syncInstance, type ChildPayload, type CustomerSyncPayload, type ExecutePayload } from '@kc/connectors';
// Kennung dieses Worker-Prozesses (nur zur Diagnose in locked_by, kein Sicherheitsmerkmal).
const WORKER_ID = `${hostname()}:${process.pid}:${randomUUID().slice(0, 8)}`;
@ -16,18 +17,20 @@ type Handler = (payload: any, job: JobMeta) => Promise<string | void>;
const handlers: Record<string, Handler> = {
'discord.notify': async (p) => {
const text = p.event === 'customer.created' ? `Neuer Kunde angelegt: ${p.customerNumber}`
: p.event === 'customer.registered' ? 'Neue Selbstregistrierung wartet auf Freigabe (Verwaltung → Kunden)'
: p.event === 'backup.failed' ? `⚠ Backup fehlgeschlagen: ${p.detail ?? ''}`.trim()
: p.event === 'backup.stale' ? `⚠ Kein aktuelles Backup: ${p.detail ?? ''}`.trim()
: p.event === 'restoretest.failed' ? `⚠ Wiederherstellungstest fehlgeschlagen: ${p.detail ?? ''}`.trim()
: p.event === 'ticket.created' ? `🎫 Neues Ticket ${p.number}: ${p.subject ?? ''}`.trim()
: p.event === 'ticket.message' ? `🎫 Neue Nachricht zu Ticket ${p.number}`
: p.event === 'system.alert' ? alertText(String(p.key), p.kind === 'recovery' ? 'recovery' : 'alarm', p.detail ?? null)
: p.event === 'invoice.issued' ? `🧾 Rechnung ${p.number} ausgestellt (${(Number(p.gross ?? 0) / 100).toLocaleString('de-DE', { style: 'currency', currency: 'EUR' })})` : null; // keine personenbezogenen Daten
if (!text) throw new Error(`Unbekanntes Ereignis: ${p.event}`);
const r = await notifyAdmin(text, String(p.event).startsWith('ticket.') ? 'tickets' : 'admin');
if (r === 'skipped') return 'übersprungen: Discord nicht konfiguriert';
},
'mail.template': async (p: { to: string; key: string; vars: Record<string, string> }) => {
const status = await sendTemplateMail(p.to, p.key, p.vars);
'mail.template': async (p: { to: string; key: string; vars: Record<string, string>; replyTicketId?: string }) => {
const status = await sendTemplateMail(p.to, p.key, p.vars, { replyTicketId: p.replyTicketId });
if (status === 'failed') throw new Error('Mailversand fehlgeschlagen (siehe Protokoll unter Einstellungen > E-Mail)');
if (status === 'no_template') throw new Error(`Unbekannte Mailvorlage: ${p.key}`);
return status === 'not_configured' ? 'übersprungen: SMTP nicht konfiguriert' : status === 'disabled' ? 'übersprungen: Vorlage deaktiviert' : 'gesendet';
@ -43,6 +46,7 @@ handlers['connector.sync'] = async (p, j) => {
handlers['order.provision'] = (p: { orderId: string }, j) => provisionOrder(p.orderId, j);
handlers['connector.child'] = (p: ChildPayload, j) => executeChild(p, j.id, j.correlationId, () => j.attempt >= j.maxAttempts);
handlers['connector.execute'] = (p: ExecutePayload, j) => executeAction(p, j.id, j.correlationId);
handlers['customer.provider_sync'] = (p: CustomerSyncPayload, j) => syncCustomerInfo(p, j.correlationId);
const backoff = (attempt: number) => Math.min(3600, 30 * 2 ** attempt); // Sekunden, exponentiell
/** Holt einen fälligen Auftrag (SKIP LOCKED) und führt ihn aus. Liefert false, wenn nichts zu tun war.

View file

@ -1,7 +1,9 @@
import { randomUUID } from 'node:crypto';
import { ImapFlow } from 'imapflow';
import { simpleParser } from 'mailparser';
import { pool } from '@kc/platform/db';
import type { PoolConnection } from 'mysql2/promise';
import { one, pool, run, tx } from '@kc/platform/db';
import { ticketFromReplyHeaders } from '@kc/platform/ticketmail';
import { decrypt } from '@kc/platform/crypto';
import { enqueue } from '@kc/platform/jobs';
import { hasFeature } from '@kc/platform/license';
@ -10,19 +12,20 @@ import { hasFeature } from '@kc/platform/license';
function htmlToText(html: string): string {
return html.replace(/<(script|style)[^>]*>[\s\S]*?<\/\1>/gi, ' ').replace(/<br\s*\/?>/gi, '\n').replace(/<\/p>/gi, '\n\n').replace(/<[^>]+>/g, ' ').replace(/&nbsp;/g, ' ').replace(/[ \t]+/g, ' ').replace(/\n{3,}/g, '\n\n').trim();
}
async function nextTicketNumber(): Promise<string> {
await pool.query("UPDATE number_sequences SET next_value = LAST_INSERT_ID(next_value + 1) WHERE name = 'ticket'");
const [r] = await pool.query('SELECT LAST_INSERT_ID() AS n') as any;
return `T-${r[0].n}`;
}
const notify = (event: string, extra: Record<string, unknown>, key: string) => enqueue('discord.notify', { event, ...extra }, { idempotencyKey: key });
const notify = (event: string, extra: Record<string, unknown>, key: string, c?: PoolConnection) => enqueue('discord.notify', { event, ...extra }, { idempotencyKey: key }, c);
/** Nach so vielen erfolglosen Versuchen wird eine Nachricht nur noch als „nicht verarbeitbar“ im Posteingang abgelegt. */
const MAX_ATTEMPTS = 5;
/**
* Ruft das konfigurierte IMAP-Postfach ab und ordnet neue Mails Tickets zu:
* 1. Betreff enthält eine Ticketnummer (T-123) UND Absender gehört zum Kunden dieses Tickets → als Nachricht angehängt.
* 2. Sonst, wenn der Absender ein bekannter aktiver Kunde ist → neues Ticket unter seinem Kundenkonto.
* 3. Sonst → landet unzugeordnet im Posteingang, Personal weist manuell zu (siehe /admin/inbox).
* Beim ersten Aktivieren (last_uid ist NULL) wird kein Bestand verarbeitet, nur ab dann neu Eingehendes.
* Ruft das konfigurierte IMAP-Postfach ab und ordnet neue Mails Tickets zu (#107):
* 1. Antwort mit gültigem, signiertem Bezug auf eine Ticket-Mail (In-Reply-To/References, siehe ticketmail.ts) UND
* Absender ist aktives Mitglied des (aktiven) Kunden dieses Tickets → als Kundenantwort angehängt.
* 2. Alles andere (auch bekannte Absender, Ticketnummer nur im Betreff) → Posteingang zur manuellen Zuordnung, mit
* Vorschlag (Ticket/Kunde). Absenderadresse und Betreff sind fälschbar und gelten nicht als Identitätsnachweis.
* Erstlauf (last_uid NULL) oder geänderte UIDVALIDITY: kein Bestand wird verarbeitet, nur ab dann neu Eingehendes.
* Schlägt eine Nachricht fehl, bleibt last_uid VOR ihr stehen und sie wird beim nächsten Lauf wiederholt
* (höchstens MAX_ATTEMPTS-mal, danach als nicht verarbeitbar im Posteingang abgelegt). Doppelte Verarbeitung
* verhindert der eindeutige Schlüssel (uid_validity, uid).
*/
export async function checkMailbox(log: (m: string) => void): Promise<void> {
const [rows] = await pool.query('SELECT * FROM imap_settings WHERE id = 1') as any;
@ -35,20 +38,37 @@ export async function checkMailbox(log: (m: string) => void): Promise<void> {
await client.connect();
const lock = await client.getMailboxLock(s.folder || 'INBOX');
try {
const mailbox = client.mailbox as { uidNext: number };
if (s.last_uid == null) {
await pool.query('UPDATE imap_settings SET last_uid = ?, last_checked_at = UTC_TIMESTAMP(3), last_error = NULL WHERE id = 1', [Math.max(0, mailbox.uidNext - 1)]);
log('IMAP: Erstlauf, Bestand wird nicht verarbeitet (nur neu Eingehendes ab jetzt).');
const mailbox = client.mailbox as { uidNext: number; uidValidity: bigint | number };
const uidValidity = Number(mailbox.uidValidity);
if (s.last_uid == null || (s.uid_validity != null && Number(s.uid_validity) !== uidValidity)) {
const reason = s.last_uid == null ? 'Erstlauf' : 'UIDVALIDITY des Postfachs hat sich geändert';
await pool.query('UPDATE imap_settings SET last_uid = ?, uid_validity = ?, failed_uid = NULL, failed_attempts = 0, last_checked_at = UTC_TIMESTAMP(3), last_error = NULL WHERE id = 1', [Math.max(0, mailbox.uidNext - 1), uidValidity]);
log(`IMAP: ${reason}, Bestand wird nicht verarbeitet (nur neu Eingehendes ab jetzt).`);
return;
}
let maxUid = s.last_uid;
for await (const msg of client.fetch(`${s.last_uid + 1}:*`, { source: true }, { uid: true })) {
if (msg.uid <= s.last_uid) continue; // Server liefert bei leerem Bereich mitunter die letzte bekannte Nachricht
maxUid = Math.max(maxUid, msg.uid);
try { await processMessage(msg.uid, msg.source as Buffer, log); }
catch (e) { log(`IMAP: Nachricht UID ${msg.uid} konnte nicht verarbeitet werden: ${(e as Error).message}`); }
if (s.uid_validity == null) await pool.query('UPDATE imap_settings SET uid_validity = ? WHERE id = 1', [uidValidity]);
let lastUid = Number(s.last_uid);
let failedUid: number | null = s.failed_uid == null ? null : Number(s.failed_uid);
let attempts = Number(s.failed_attempts ?? 0);
let error: string | null = null;
for await (const msg of client.fetch(`${lastUid + 1}:*`, { source: true }, { uid: true })) {
if (msg.uid <= lastUid) continue; // Server liefert bei leerem Bereich mitunter die letzte bekannte Nachricht
try {
await processMessage(msg.uid, uidValidity, msg.source as Buffer, log);
} catch (e) {
const m = String((e as Error).message).slice(0, 400);
attempts = failedUid === msg.uid ? attempts + 1 : 1; failedUid = msg.uid;
if (attempts < MAX_ATTEMPTS) {
error = `Nachricht UID ${msg.uid} nicht verarbeitet (Versuch ${attempts}/${MAX_ATTEMPTS}): ${m}`;
log(`IMAP: ${error}`);
break; // last_uid bleibt vor dieser Nachricht stehen → nächster Lauf wiederholt sie
}
await storeUnprocessable(msg.uid, uidValidity, msg.source as Buffer, m).catch((e2) => log(`IMAP: Ablage von UID ${msg.uid} fehlgeschlagen: ${(e2 as Error).message}`));
log(`IMAP: Nachricht UID ${msg.uid} nach ${attempts} Versuchen als nicht verarbeitbar im Posteingang abgelegt: ${m}`);
}
lastUid = msg.uid; failedUid = null; attempts = 0;
}
await pool.query('UPDATE imap_settings SET last_uid = ?, last_checked_at = UTC_TIMESTAMP(3), last_error = NULL WHERE id = 1', [maxUid]);
await pool.query('UPDATE imap_settings SET last_uid = ?, failed_uid = ?, failed_attempts = ?, last_checked_at = UTC_TIMESTAMP(3), last_error = ? WHERE id = 1', [lastUid, failedUid, attempts, error]);
} finally { lock.release(); }
await client.logout();
} catch (e) {
@ -60,63 +80,61 @@ export async function checkMailbox(log: (m: string) => void): Promise<void> {
}
const TICKET_NUMBER = /\bT-(\d+)\b/i;
async function processMessage(uid: number, source: Buffer, log: (m: string) => void): Promise<void> {
const isDuplicate = (e: unknown) => (e as { code?: string }).code === 'ER_DUP_ENTRY';
interface Parsed { fromEmail: string; fromName: string | null; subject: string | null; bodyText: string; receivedAt: Date; messageId: string | null; inReplyTo?: string; references?: string | string[] }
async function parse(source: Buffer): Promise<Parsed> {
const parsed = await simpleParser(source);
const fromAddr = parsed.from?.value?.[0];
const fromEmail = (fromAddr?.address ?? '').toLowerCase().slice(0, 254);
if (!fromEmail) { log(`IMAP: Nachricht UID ${uid} ohne lesbare Absenderadresse, übersprungen.`); return; }
const fromName = (fromAddr?.name ?? '').slice(0, 200) || null;
const subject = (parsed.subject ?? '').slice(0, 500) || null;
const bodyText = (parsed.text ?? (parsed.html ? htmlToText(parsed.html as string) : '')).slice(0, 20000);
const receivedAt = parsed.date ?? new Date();
const messageId = (parsed.messageId ?? '').slice(0, 998) || null;
const id = randomUUID();
return {
fromEmail: (fromAddr?.address ?? '').toLowerCase().slice(0, 254), fromName: (fromAddr?.name ?? '').slice(0, 200) || null,
subject: (parsed.subject ?? '').slice(0, 500) || null, bodyText: (parsed.text ?? (parsed.html ? htmlToText(parsed.html as string) : '')).slice(0, 20000),
receivedAt: parsed.date ?? new Date(), messageId: (parsed.messageId ?? '').slice(0, 998) || null, inReplyTo: parsed.inReplyTo, references: parsed.references,
};
}
// 1) Ticketnummer im Betreff + Absender gehört zum Kunden dieses Tickets
const m = subject ? TICKET_NUMBER.exec(subject) : null;
if (m) {
const [tRows] = await pool.query('SELECT * FROM tickets WHERE number = ?', [`T-${m[1]}`]) as any;
const ticket = tRows[0];
if (ticket) {
const [uRows] = await pool.query("SELECT id FROM users WHERE email = ? AND status = 'active'", [fromEmail]) as any;
const user = uRows[0];
if (user) {
const [memRows] = await pool.query('SELECT 1 AS x FROM memberships WHERE user_id = ? AND org_id = ?', [user.id, ticket.org_id]) as any;
if (memRows[0]) {
await pool.query('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), ticket.id, user.id, 'customer', bodyText || '(kein Text)']);
await pool.query("UPDATE tickets SET status = 'pending_staff', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [ticket.id]);
await pool.query('INSERT INTO inbox_messages (id, uid, message_id, from_email, from_name, subject, body_text, received_at, status, ticket_id, matched_user_id) VALUES (?,?,?,?,?,?,?,?,?,?,?)',
[id, uid, messageId, fromEmail, fromName, subject, bodyText, receivedAt, 'matched', ticket.id, user.id]);
await notify('ticket.message', { number: ticket.number }, `mail-in:${id}`);
log(`IMAP: Nachricht von ${fromEmail} zu Ticket ${ticket.number} hinzugefügt.`);
/** Verarbeitet eine Nachricht vollständig in EINER Transaktion (Inbox-Zeile, Ticketnachricht, Status, Benachrichtigung). */
export async function processMessage(uid: number, uidValidity: number, source: Buffer, log: (m: string) => void): Promise<void> {
const p = await parse(source);
const id = randomUUID();
const inboxRow = (c: PoolConnection, status: string, extra: { ticketId?: string | null; userId?: string | null; suggestedTicketId?: string | null; suggestedUserId?: string | null } = {}) =>
run('INSERT INTO inbox_messages (id, uid, uid_validity, message_id, from_email, from_name, subject, body_text, received_at, status, ticket_id, matched_user_id, suggested_ticket_id, suggested_user_id) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)',
[id, uid, uidValidity, p.messageId, p.fromEmail || '(unbekannt)', p.fromName, p.subject, p.bodyText, p.receivedAt, status, extra.ticketId ?? null, extra.userId ?? null, extra.suggestedTicketId ?? null, extra.suggestedUserId ?? null], c);
try {
await tx(async (c) => {
// 1) Signierter Antwort-Bezug + Absender ist aktives Mitglied des aktiven Kunden dieses Tickets
const replyTicketId = ticketFromReplyHeaders(p.inReplyTo, p.references);
if (replyTicketId && p.fromEmail) {
const t = await one("SELECT t.id, t.number, t.org_id FROM tickets t JOIN organizations o ON o.id = t.org_id AND o.status = 'active' WHERE t.id = ? FOR UPDATE", [replyTicketId], c);
const u = t && await one("SELECT u.id FROM users u JOIN memberships m ON m.user_id = u.id AND m.org_id = ? WHERE u.email = ? AND u.status = 'active' AND u.kind = 'customer'", [t.org_id, p.fromEmail], c);
if (t && u) {
await inboxRow(c, 'matched', { ticketId: t.id, userId: u.id }); // zuerst: Dublette bricht hier ab, bevor etwas angehängt wird
await run('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), t.id, u.id, 'customer', p.bodyText || '(kein Text)'], c);
await run("UPDATE tickets SET status = 'pending_staff', last_message_at = UTC_TIMESTAMP(3), resolved_at = NULL, closed_at = NULL WHERE id = ?", [t.id], c);
await notify('ticket.message', { number: t.number }, `mail-in:${id}`, c);
log(`IMAP: Antwort zu Ticket ${t.number} angehängt (signierter Antwort-Bezug).`);
return;
}
}
}
// 2) Kein Nachweis → Posteingang, mit Vorschlag für das Personal
const m = p.subject ? TICKET_NUMBER.exec(p.subject) : null;
const sugTicket = m ? await one('SELECT id FROM tickets WHERE number = ?', [`T-${m[1]}`], c) : undefined;
const sugUser = p.fromEmail ? await one("SELECT id FROM users WHERE email = ? AND status = 'active' AND kind = 'customer'", [p.fromEmail], c) : undefined;
await inboxRow(c, 'unmatched', { suggestedTicketId: replyTicketId ?? sugTicket?.id ?? null, suggestedUserId: sugUser?.id ?? null });
log(`IMAP: Nachricht UID ${uid} liegt zur Zuordnung im Posteingang${sugTicket || sugUser ? ' (mit Vorschlag)' : ''}.`);
});
} catch (e) {
if (isDuplicate(e)) { log(`IMAP: Nachricht UID ${uid} wurde bereits verarbeitet, übersprungen.`); return; }
throw e;
}
// 2) Bekannter aktiver Kunde ohne (verifizierten) Ticketbezug → neues Ticket
const [uRows2] = await pool.query("SELECT id FROM users WHERE email = ? AND status = 'active' AND kind = 'customer'", [fromEmail]) as any;
const user2 = uRows2[0];
if (user2) {
const [memRows2] = await pool.query("SELECT org_id FROM memberships WHERE user_id = ? ORDER BY (role = 'owner') DESC LIMIT 1", [user2.id]) as any;
const org = memRows2[0];
if (org) {
const ticketId = randomUUID();
const number = await nextTicketNumber();
await pool.query('INSERT INTO tickets (id, number, org_id, subject, status, priority, created_by) VALUES (?,?,?,?,?,?,?)',
[ticketId, number, org.org_id, subject || '(kein Betreff)', 'pending_staff', 'normal', user2.id]);
await pool.query('INSERT INTO ticket_messages (id, ticket_id, author_id, author_kind, body) VALUES (?,?,?,?,?)', [randomUUID(), ticketId, user2.id, 'customer', bodyText || '(kein Text)']);
await pool.query('INSERT INTO inbox_messages (id, uid, message_id, from_email, from_name, subject, body_text, received_at, status, ticket_id, matched_user_id) VALUES (?,?,?,?,?,?,?,?,?,?,?)',
[id, uid, messageId, fromEmail, fromName, subject, bodyText, receivedAt, 'created', ticketId, user2.id]);
await notify('ticket.created', { number, subject: (subject || '').slice(0, 100) }, `mail-in:${id}`);
log(`IMAP: Neues Ticket ${number} aus Mail von ${fromEmail} angelegt.`);
return;
}
}
// 3) Unbekannter oder nicht zuordenbarer Absender → Posteingang zur manuellen Zuordnung
await pool.query('INSERT INTO inbox_messages (id, uid, message_id, from_email, from_name, subject, body_text, received_at, status) VALUES (?,?,?,?,?,?,?,?,?)',
[id, uid, messageId, fromEmail, fromName, subject, bodyText, receivedAt, 'unmatched']);
log(`IMAP: Nachricht von ${fromEmail} konnte niemandem zugeordnet werden, liegt im Posteingang.`);
}
/** Letzter Ausweg nach MAX_ATTEMPTS Fehlversuchen: Rohdaten so weit wie möglich als unzugeordnete Nachricht ablegen. */
async function storeUnprocessable(uid: number, uidValidity: number, source: Buffer, error: string): Promise<void> {
const head = source.subarray(0, 20000).toString('utf8');
const from = /^From:\s*(.*)$/im.exec(head)?.[1]?.slice(0, 254) ?? '(unbekannt)';
const subject = /^Subject:\s*(.*)$/im.exec(head)?.[1]?.slice(0, 500) ?? null;
try {
await run("INSERT INTO inbox_messages (id, uid, uid_validity, from_email, subject, body_text, received_at, status, processing_error) VALUES (?,?,?,?,?,?,UTC_TIMESTAMP(3),'unmatched',?)",
[randomUUID(), uid, uidValidity, from, subject, '(Nachricht konnte nicht automatisch gelesen werden – bitte im Postfach ansehen)', error]);
} catch (e) { if (!isDuplicate(e)) throw e; }
}

View file

@ -144,4 +144,4 @@
"customerActions": []
}
]
}
}

View file

@ -0,0 +1,14 @@
# ADR 0003: Job-Queue in MariaDB
Status: angenommen (beschreibt den umgesetzten Stand, 06.10.2026)
**Kontext:** API und Worker sind getrennte Prozesse. Asynchrone Arbeit (Provider-Aktionen, Mails, Discord, Abgleich) muss einen Neustart überstehen, darf nicht doppelt ausgeführt werden und muss nachvollziehbar sein. Eine zusätzliche Infrastruktur (Redis/RabbitMQ) soll vermieden werden.
**Entscheidung:** Tabelle `jobs` in MariaDB.
- **Einplanen:** `enqueue(type, payload, { idempotencyKey, correlationId, runAt }, connection?)` – `INSERT IGNORE` auf den Idempotenzschlüssel; mit `connection` in derselben Transaktion wie die fachliche Änderung (kein Auftrag ohne Datensatz und umgekehrt).
- **Abholen:** `SELECT … FOR UPDATE SKIP LOCKED` (ältester fälliger Job), dann `status='running'` mit zufälliger `lease_id`. Mehrere Worker sind möglich.
- **Herzschlag/Lease:** während der Ausführung alle 60 s `locked_at` aktualisieren. Ergebnis wird nur geschrieben, wenn die `lease_id` noch passt – ein inzwischen übernommener Job wird nicht überschrieben.
- **Wiederanlauf:** `recoverStale` gibt Jobs ohne Herzschlag (> 5 min) wieder frei; **destruktive** Aufträge (`payload.destructive` bzw. `terminate`) gehen stattdessen auf `needs_review`, weil ihr Ergebnis beim Anbieter geprüft werden muss.
- **Fehler:** Wiederholung mit Backoff bis `max_attempts`; `JobFailure(retry=false)` beendet sofort mit `failed` oder `needs_review`.
- **Überwachung:** Stau (fällige Jobs > 10 min) und `needs_review` lösen Betriebsalarme aus (`platform/monitor.ts`, siehe `docs/betrieb-backup-restore.md`).
**Folgen:** Kein zusätzlicher Dienst; Transaktionen über Job und Fachdaten möglich. Durchsatz ist für die erwartete Last (Dutzende Jobs pro Minute) ausreichend; bei deutlich mehr Last wäre eine eigene Queue zu prüfen.

View file

@ -0,0 +1,8 @@
# ADR 0004: Rechnungen im Kundencenter selbst erzeugen (kein Invoice Ninja)
Status: angenommen (Entscheidung Björn, 26.09.2026; dokumentiert 06.10.2026)
**Kontext:** Ursprünglich war Invoice Ninja als externes Rechnungssystem vorgesehen. Für ein kleines Hosting-/Lizenzgeschäft ist ein zweites System mit eigener Kunden- und Produktpflege doppelte Arbeit und eine zusätzliche Angriffsfläche.
**Entscheidung:** Rechnungen entstehen im Modul `invoices` des Kundencenters (Entwurf → Ausstellen → bezahlt/Storno), fortlaufende Nummern, Snapshots von Absender/Empfänger, Storno statt Änderung, PDF, DATEV-Export, Abrechnungslauf aus Verträgen.
**Folgen:** Rechts- und Steuerpflichten (Pflichtangaben, Archivierung/GoBD, E-Rechnung) liegen jetzt beim Kundencenter. Offene fachliche Freigaben und bekannte Lücken stehen in `docs/rechnungs-systemgrenze.md`; vor dem Versand an echte Kunden ist eine Prüfung durch Steuerberatung nötig. Ein externes System bleibt über Export/Connector später anbindbar.

82
docs/architektur.md Normal file
View file

@ -0,0 +1,82 @@
# Architektur
Stand: 06.10.2026 (Code-Stand nach den Plane-Tickets #95–#119). Entscheidungen im Detail: `docs/adr/`.
## Überblick
Modularer Monolith in einem pnpm-Monorepo mit drei Prozessen und einer Datenbank:
| Prozess | Paket | Aufgabe | systemd |
|---|---|---|---|
| API | `apps/api` (Fastify) | HTTP-API unter `/v1`, Rechte, Validierung, Audit, Jobs einplanen, Worker-Watchdog | `kc-api` (:4100, nur 127.0.0.1) |
| Worker | `apps/worker` | Job-Queue abarbeiten, Connector-Abgleich, Vertragslauf, Abrechnungslauf, IMAP-Abruf, Discord-Bot, Lizenzprüfung, Betriebsalarme | `kc-worker` |
| Web | `apps/web` (Next.js) | Oberfläche; spricht ausschließlich über den Proxy `/api/*` → API | `kc-web` (:4101, nur 127.0.0.1) |
Datenbank: MariaDB (`utf8mb4_unicode_ci`), Schema über nummerierte Migrationen in `migrations/` (`pnpm migrate`, Sperre + Wiederanlauf siehe `docs/betrieb-backup-restore.md`). Kein Redis, keine Message-Queue – die Job-Queue liegt in MariaDB (ADR 0003).
## Pakete und erlaubte Abhängigkeiten
```
apps/web ──HTTP──▶ apps/api ─┐
├─▶ packages/connectors ─▶ packages/connector-{keyhelp,plesk,licensing,mock} ─▶ packages/connector-sdk
apps/worker ─────┤ │
└─▶ packages/platform ◀──┘
```
| Paket | Darf importieren | Inhalt |
|---|---|---|
| `packages/connector-sdk` | nichts Internes | Connector-Vertrag (`Connector`, Capabilities, `NormalizedResource`, Fehlerklassen, `httpJson`) |
| `packages/connector-*` | nur `@kc/connector-sdk` | Anbieter-Anbindungen; kennen weder Datenbank noch Apps |
| `packages/platform` | keine `@kc`-Pakete | gemeinsame Schicht für API und Worker: DB, Konfiguration, Krypto, Audit-Kette, Jobs, Mail, Lizenz/Edition, Preise, Statusautomaten, Abrechnungslauf, Betriebsalarme, Ticket-Policy, CSV, Nummernkreise |
| `packages/connectors` | `platform`, `connector-sdk`, `connector-*` | Registry der Connectoren, Abgleich, Provisionierung, Lifecycle-Aktionen, Vertragslauf |
| `apps/api` | `platform`, `connectors`, `connector-sdk` | Module (s. u.), `core/` (Auth, Policy, Fehler, Re-Exporte der Plattform), `ops/` (Backup, Watchdog) |
| `apps/worker` | `platform`, `connectors`, `connector-sdk` | Job-Handler, Discord, IMAP; **kein** Import von API-Code |
| `apps/web` | keine `@kc`-Pakete, nichts außerhalb `apps/web` | UI; Rechte kommen aus `/auth/me`, durchgesetzt wird nur in der API |
Innerhalb der API importieren Module einander **nicht**; sie kommunizieren über `core/`, `packages/platform` und Jobs.
**Automatische Prüfung:** `node ops/test/check-boundaries.mjs` (läuft in `ops/test/ci.sh` und damit in der CI; `--selftest` prüft die Regeln selbst). Ein verbotener Import – z. B. `apps/api/src/modules/tickets/*` → `../invoices/index.js` oder `packages/connector-plesk` → `@kc/platform` – lässt den Lauf scheitern. Tests (`test/`, `*.test.ts`) sind ausgenommen (API-Tests treiben den Worker-Job-Runner direkt an).
## API-Module
Jedes Modul ist ein `KcModule` (`apps/api/src/core/module.ts`): Name, zusätzliche Rechte je Personal-/Organisationsrolle, `register(app)` mit den Routen. Eingetragen in `apps/api/src/modules/index.ts`.
| Modul | Zuständigkeit |
|---|---|
| system | `/health`, `/ready`, Betriebsübersicht (`/admin/system`: Jobs, Backup, Worker-Herzschlag, Betriebsalarme) |
| identity | Login, 2FA (TOTP, Wiederherstellungscodes), Sitzungen, Einladungen, Passwort-Reset, Personalverwaltung, Impersonation |
| customers | Kunden/Organisationen, Rechnungsprofil, Mitglieder, Übernahme aus Anbietern, Kundengrenze |
| audit | Audit-Protokoll (Hash-Kette), Export |
| connectors | Verbindungen (verschlüsselte Zugangsdaten), Capabilities, Abgleich |
| resources | Hosting-Konten/Lizenzen/Unterobjekte, Aktionen, Panel-Login, Auftragsliste |
| catalog | Produkte, Versionen, Laufzeitpreise |
| domains | Domain-Aufstellung, EK/VK, CSV, Verfügbarkeit |
| orders | Bestellungen, Freigabe, Verträge, Kündigung |
| tickets | Tickets, Nachrichten, Anhänge, **Posteingang** (IMAP-Mails, Zuordnung) |
| invoices | Rechnungen (Entwurf/Ausstellen/Storno), PDF, DATEV/CSV, Firmenstammdaten, Mahnüberblick, **Abrechnungslauf** |
| backup | Backup-Ziele, Passwort, Status |
| mail | SMTP, Vorlagen, Protokoll, **IMAP-Einstellungen** |
| discord | Bot-Einstellungen, OAuth-Verknüpfung |
| license | eigene Lizenz der Installation (Edition, Testmodus) |
| licensing | Lizenzverwaltung für weiterverkaufte Lizenzen (Licensing-Connector) |
### Mail-Plattform (#106/#107)
Versand: `packages/platform/src/mail.ts` (SMTP-Konfiguration aus `mail`-Modul, DB-Vorlagen, Absender je Bereich, Protokoll). Ticket-Mails tragen eine signierte Message-ID (`platform/ticketmail.ts`). Empfang: der Worker ruft IMAP ab (`apps/worker/src/mailbox.ts`) und schreibt in `inbox_messages`/Tickets; die Bedienung (Zuordnen/Anhängen/Ignorieren) liegt im Tickets-Modul. Zuordnung nur mit signiertem Antwort-Bezug, sonst Posteingang.
## Kommunikation über Jobs
API und Worker teilen sich keine Prozessdaten. Alles Asynchrone läuft über die Tabelle `jobs` (`platform/jobs.ts: enqueue`, in derselben Transaktion wie die fachliche Änderung möglich, Idempotenzschlüssel). Beispiele: `discord.notify`, `mail.template`, Connector-Aktionen, `discord.ticket_sync`. Details ADR 0003.
## Querschnitt
- **Rechte:** `core/policy.ts` (RBAC + Objektprüfung `canInOrg`); Module registrieren ihre Rechte. Ticket-Rechte zusätzlich in `platform/ticketPolicy.ts`, damit der Worker (Discord) dieselben Regeln nutzt. Rollenmatrix: `docs/sicherheit-und-bedrohungsmodell.md`.
- **Audit:** unveränderliche Hash-Kette (`platform/audit.ts`, Trigger verhindern UPDATE/DELETE).
- **Geheimnisse:** AES-GCM mit `KC_SECRET_KEY` (`platform/crypto.ts`); Konfiguration in `/etc/kundencenter/*.env`, nie im Repo.
- **Edition/Lizenz:** `platform/license.ts` (signierte Antworten, Grenzen transaktional).
- **Zeit:** alles in UTC (DB-Sitzung `time_zone = '+00:00'`).
## Bekannte Abweichungen / offene Punkte
- Die Modulmatrix der eigenen Lizenz (billing/domains/provisioning/automation) ist noch nicht entschieden (#113); bis dahin gelten discord/imap/datev/backup_remote.
- Der frühere doppelte Config-Lader (ADR 0002) ist aufgelöst: `apps/api/src/core/config.ts` re-exportiert `@kc/platform/config`.

View file

@ -61,17 +61,59 @@ systemctl start kc-backup && journalctl -u kc-backup -n 30 --no-pager -o cat
Ein ausgefallenes Ziel lässt den Lauf als Fehler zählen (Meldung), das lokale Backup bleibt erhalten.
## Wiederherstellung (Notfall)
1. Neuer/repariertes Server mit MariaDB, Node und `age`; Kundencenter-Code nach `/srv/kundencenter` (Repo), `pnpm install && pnpm build`.
2. Sicherungsdatei holen (lokal, Ziel) und den **privaten Schlüssel** bereitlegen.
Voraussetzung: das **Backup-Passwort** (Einstellungen → Backup) bzw. bei Alt-Sicherungen der private age-Schlüssel – getrennt vom Server und vom Ziel verwahrt (#65).
1. Neuer/reparierter Server mit MariaDB, Node 24, pnpm, `gpg` (und `age` für Alt-Sicherungen); Code nach `/srv/kundencenter`, `pnpm install --frozen-lockfile && pnpm build` (als Benutzer `kundencenter`), systemd-Units aus `ops/systemd/` installieren.
2. Sicherungsdatei vom Ziel holen (z. B. KeyDisc), Dateiname `kundencenter-DATUM-….tar.gz.gpg` (Alt: `….tar.gz.age`).
3. Entschlüsseln und entpacken:
```bash
age -d -i backup-age-key.txt -o archive.tar.gz kundencenter-DATUM-....tar.gz.age
mkdir restore && tar -xzf archive.tar.gz -C restore # enthält db.sql, config/*.env, manifest.json
gpg --decrypt -o archive.tar.gz kundencenter-DATUM-….tar.gz.gpg # fragt das Backup-Passwort
# Alt-Sicherung: age -d -i backup-age-key.txt -o archive.tar.gz kundencenter-DATUM-….tar.gz.age
mkdir restore && tar -xzf archive.tar.gz -C restore # db.sql, config/*.env, manifest.json, ticket-attachments/
```
4. Konfiguration zurück: `cp restore/config/*.env /etc/kundencenter/` (chmod 600), Datenbank und Benutzer anlegen (nur Rechte auf `kundencenter`).
5. Datenbank einspielen: `mysql -u… -p kundencenter < restore/db.sql`
6. Dienste starten (`kc-api`, `kc-worker`, `kc-web`), prüfen: `/v1/ready`, Anmeldung, Übersicht, **Audit-Protokoll → „Integrität prüfen“**.
7. Erwartung: Datenverlust höchstens bis zum letzten Backup (bis zu 24 h), Wiederherstellung ca. 30 Minuten.
4. Konfiguration zurück: `cp restore/config/*.env /etc/kundencenter/` (root, chmod 600). `KC_SECRET_KEY` muss der gesicherte sein, sonst sind 2FA-Geheimnisse und Zugangsdaten unlesbar.
5. Datenbank anlegen (`utf8mb4_unicode_ci`) und einspielen. Trigger der Audit-Tabelle tragen einen DEFINER – bei einem anderen DB-Benutzer vorher entfernen (gleiche Regel wie der automatische Restore-Test):
```bash
sed -E 's#/\*!50017 DEFINER=`[^`]*`@`[^`]*`\*/ ?##g; s# DEFINER=`[^`]*`@`[^`]*`##g' restore/db.sql | mysql -u <benutzer> -p <datenbank>
```
6. Anhänge zurück: `cp -a restore/ticket-attachments /var/lib/kundencenter/` (Eigentümer `kundencenter`). Anzahl/Größe mit `manifest.json → attachments` vergleichen.
7. `pnpm migrate` (wendet nur Neueres an), Dienste starten, prüfen: `/v1/ready`, Anmeldung, Übersicht (Betriebsalarme leer, Worker-Herzschlag frisch), **Audit-Protokoll → „Integrität prüfen“**, ein Ticket-Anhang öffnen.
8. Erwartung: Datenverlust höchstens bis zum letzten Backup (bis zu 24 h), Wiederherstellung ca. 30–60 Minuten.
Der wöchentliche automatische Wiederherstellungstest prüft die Schritte 3, 5 und 6 in der Wegwerf-Datenbank `kundencenter_restoretest` (Prüfsummen, Zeilenzahlen, Migrationen, Audit-Kette, Anhänge laut Manifest, Lesbarkeit der Geheimnisse).
## Dienste, Health und Wiederanlauf
| Dienst | Start nach | Health | Neustart | Logs |
|---|---|---|---|---|
| `kc-api` (:4100) | network-online, mariadb | `GET /v1/health` (lebt), `/v1/ready` (DB) | `Restart=always`, 3 s | `journalctl -u kc-api` |
| `kc-worker` | network-online, mariadb, kc-api | `127.0.0.1:4102/health` (Schleife), `/ready` (+DB); Herzschlag in `system_heartbeats` | `Restart=always`, 3 s | `journalctl -u kc-worker` |
| `kc-web` (:4101) | network-online, kc-api | HTTP 200 auf `/login` | `Restart=always`, 3 s | `journalctl -u kc-web` |
| `kc-backup.timer` / `kc-restore-test.timer` | – | `backup-status.json`, Dashboard | Persistent (holt nach) | `journalctl -u kc-backup` |
| `kc-backup-request.path` | – | Anfragen aus der Oberfläche | – | `journalctl -u kc-backup-request` |
Nach einem Host-Neustart starten alle Dienste automatisch (enabled). Reihenfolge: MariaDB → API → Worker/Web. Ist die DB beim Start noch nicht bereit, beendet sich der Prozess und systemd startet ihn nach 3 s neu. Ausfälle melden die Betriebsalarme (Abschnitt unten); ein ausgefallener Worker wird von der API per Mail gemeldet.
## Vor größeren Änderungen
Vor Migrationen oder Updates manuell sichern: `systemctl start kc-backup`. Rollback einer fehlerhaften Migration = Wiederherstellung (Abschnitt oben) in eine Wegwerf-Datenbank prüfen, dann produktiv einspielen.
## Migrationen: Sperre und abgebrochene Läufe
`pnpm migrate` hält für den ganzen Lauf eine eigene Datenbankverbindung mit der Sperre `kc_migrate`; ein zweiter, gleichzeitiger Lauf wartet höchstens 10 s und bricht dann ab. Bereits angewendete Migrationen sind per SHA-256-Prüfsumme gegen nachträgliche Änderung geschützt.
DDL ist in MariaDB nicht transaktional. Bricht eine Migration mitten drin ab, steht der Fortschritt in `schema_migrations_dirty` (angewendete Anweisungen, Fehlermeldung). Jeder weitere `pnpm migrate` verweigert dann die Arbeit mit einem Hinweis. Vorgehen:
1. Fehlermeldung lesen, Datenbankzustand prüfen (`SELECT * FROM schema_migrations_dirty`), Ursache beheben (z. B. Datenkonflikt bereinigen). Die Migrationsdatei dabei **nicht** ändern – sonst ist Fortsetzen nicht mehr sicher und wird abgelehnt.
2. `pnpm migrate --resume` setzt bei der fehlgeschlagenen Anweisung fort; die bereits angewendeten werden nicht wiederholt.
3. Lässt sich der Zustand nicht sauber herstellen: Sicherung von vor dem Deploy in eine Wegwerf-Datenbank prüfen und einspielen (siehe oben).
## Betriebsalarme und Entwarnung
Zustände werden minütlich geprüft und in `system_alerts` geführt; aktive Alarme stehen im Dashboard (Karte „Betriebsalarme“), auch wenn Discord/Mail nicht eingerichtet sind. Gemeldet wird je Vorfall einmal nach der Karenzzeit, die Entwarnung folgt, sobald der Zustand behoben ist.
| Zustand | Prüft | Karenz | Meldung |
|---|---|---|---|
| Lizenzserver nicht erreichbar (Netzwerk, HTTP 5xx/429) | Worker, Wiederholung alle 10 min | 30 min | Discord (Ticket-/Admin-Kanal) |
| Problem mit der eigenen Lizenz (Program-Key falsch, Antwort abgelehnt, Lizenz ungültig/abgelaufen) | Worker | sofort | Discord |
| Warteschlange staut sich (fällige Aufträge > 10 min unbearbeitet) | Worker | 5 min | Discord |
| Aufträge warten auf Prüfung (`needs_review`) | Worker | sofort | Discord |
| kc-worker arbeitet nicht (Herzschlag > 3 min alt) | API | 2 min | Mail an alle aktiven Superadmins (Discord läuft im Worker) |
Ohne hinterlegten Lizenzschlüssel (Testmodus) gibt es keine Lizenzalarme.

View file

@ -21,7 +21,22 @@ Paket `packages/connector-keyhelp`, getestet gegen einen nach der Definition nac
7. Listen liefern alles (kein Paging): bei sehr vielen Kunden dauert der Abgleich (Statistik je Kunde, 4 parallel).
### Noch nicht umgesetzt
DNS-Editor, Cronjobs, Verzeichnisschutz, PHP-Einstellungen je Kunde, Zertifikate hochladen, Fail2Ban-Entsperren, Backup-Liste anzeigen; Hauptdomain bei der Bestellung erfragen; Kündigung mit `delete_on` statt Sperre; Tarifwechsel in der Oberfläche.
Ausbau in Teilschritten (#74) – Stufe 1 **umgesetzt (nur lesend)**: DNS-Einträge der Hauptdomains des Kunden (`GET /dns/{id}`, DKIM wird nicht ausgegeben) und Verzeichnisschutz (`GET /directory-protections`, gefiltert auf den Kunden, ohne Passwort/Hash) als Reiter „DNS“ und „Verzeichnisschutz“ in der Ressourcenansicht.
| Teilschritt | API | Stand |
|---|---|---|
| DNS lesen | `GET /dns/{id}` | umgesetzt |
| Verzeichnisschutz lesen | `GET /directory-protections` | umgesetzt |
| Cronjobs lesen | `GET /scheduled-tasks` | offen (nächster Schritt) |
| DNS ändern | `PUT /dns/{id}` (ersetzt die Zone) | offen – erst mit Testkonto (#73), da Fehler Mail/Web des Kunden lahmlegen |
| Verzeichnisschutz anlegen/ändern | `POST/PUT /directory-protections` | offen (Passwort als Secret wie bei FTP) |
| Cronjobs anlegen/ändern | `/scheduled-tasks` | offen |
| Zertifikat hochladen | `POST /certificates` | offen (privater Schlüssel nur als Secret, nie gespeichert) |
| Fail2Ban-Liste / Entsperren | `/fail2ban/banned-ips` | nur Personal (serverweit, enthält fremde IPs) – offen |
| Backup-Liste | `/backups/operations` | nur Personal (serverweit) – offen; Wiederherstellung per API nicht möglich |
| Kündigung mit `delete_on`, Tarifwechsel in der Oberfläche | `PUT /clients/{id}` | offen |
Schreibende Schritte werden einzeln mit Eigentums-/Rollenprüfung und Fake-Tests gebaut; die Live-Abnahme bindet an ein freigegebenes Testkonto (#73).
# (Auswertung der API-Definition)

View file

@ -0,0 +1,77 @@
# Connector: Lizenzsystem (licensing.flessinglabs.com)
Stand: 06.10.2026, abgeleitet aus `packages/connector-licensing/src/index.ts` (Ressourcen-Connector) und `src/admin.ts` (Lizenzverwaltung im Kundencenter). Ersetzt die alte Bestandsanalyse von 26.09. (deren Lückenliste ist überholt, siehe Abschnitt 5). Für die **eigene** Lizenz der Installation (FLS1-signierte `/license/verify`-Antworten) siehe `packages/platform/src/license.ts` und `docs/sicherheit-und-bedrohungsmodell.md` (T16).
## 1. Verbindung und Authentisierung
| Feld | Bedeutung |
|---|---|
| `baseUrl` | z. B. `http://127.0.0.1:8001` (Lizenzsystem auf demselben Server) |
| `token` (Secret) | **empfohlen:** Service-Token, Header `Authorization: Bearer …`, kein Login nötig |
| `username`/`password` (Secret, Altweg) | Login über `POST /token` (Form), JWT 20 min im Speicher gecacht, bei 401 einmal neu angemeldet |
| `timezone` | nur für ältere Lizenzsysteme ohne `utc_timestamps` |
Benötigte Scopes eines Service-Tokens (laut Verwaltungs-Client): `programs:read`, `products:read`, `licenses:read`, `licenses:write` (anlegen, ändern, Lebenszyklus, Entitlement, Trial) und `activations:reset` (Aktivierung freigeben). `revoke` nur, wenn Lizenzen aus dem Kundencenter widerrufen werden sollen. Die aktive Live-Verbindung nutzt noch Benutzer/Passwort (Stand Codex-Prüfung 06.10.) → Umstellung #60/#43.
## 2. Fähigkeitserkennung
`GET /` liefert `features` (60 s gecacht). Der Connector schaltet abhängig davon frei:
| Feature | Wirkung im Connector |
|---|---|
| `utc_timestamps` | Zeiten werden als UTC gelesen/geschrieben (sonst Umrechnung aus der konfigurierten Ortszeit) |
| `lifecycle` | sperren/entsperren/verlängern über eigene Endpunkte (`POST /licenses/{id}/{action}`), sonst Altweg `PUT /licenses/{id}` |
| `key_prefix` | Edition per Schlüssel-Präfix (Altmodell; neu: Produkt-ID, #63) |
| `explicit_expiry` | festes Ablaufdatum bei Anlage |
| `customer_info` | Kundenkontext bei Anlage (Name, E-Mail, Kontakt, Kundennummer, Bestell-/Vertragsnummer, Quelle „Kundencenter“) |
`capabilities()`: Lesen immer. Schreiben nur gemäß Rechten (#43): Mit Service-Token zählen die in der Verbindung eingetragenen **Scopes** (Feld „Scopes des Service-Tokens“ – das Lizenzsystem bietet keine Introspektion; ohne Eintrag ist die Verbindung nur lesend): `licenses:suspend` → sperren/entsperren, `licenses:extend` → verlängern, `licenses:write` → anlegen, `licenses:read` → Schlüssel anzeigen, `licenses:revoke` → widerrufen (`terminate`, destruktiv). Mit Benutzer/Passwort (Lizenzsystem-Benutzer = alle Rechte) wie bisher ohne Widerruf. Ein 403 (fehlender Scope) wird als „fehlendes Recht“ gemeldet und nicht als Anmeldefehler; nur 401 löst beim Altweg eine erneute Anmeldung aus. Lebenszyklus-Aufrufe senden `Idempotency-Key: kc:<Auftrags-ID>`. Health prüft `/ready` (Fallback `/`).
## 3. Endpunkte, die das Kundencenter nutzt
| Methode/Pfad | Zweck | Wo |
|---|---|---|
| `GET /ready` (Fallback `GET /`) | Health inkl. Datenbank | Connector |
| `GET /` | Features | Connector |
| `POST /token` | Login (Altweg) | Connector, Verwaltung |
| `GET /programs/?limit=1000` | Programme (Namen) | Katalog, Abgleich, Anlage |
| `GET /products/groups` | Produktkatalog (Gruppen → Produkte, Preis, Dauer, Module, Plan, Kundengrenze, Add-ons) | Katalogimport, Vergabe |
| `GET /licenses/?limit=1000` | Abgleich aller Lizenzen | Connector `listResources` |
| `GET /licenses/{id}` | Detail, Schlüssel nur für `reveal` | Connector, Verwaltung |
| `GET /licenses/{id}/activations` | Aktivierungen | Verwaltung |
| `DELETE /licenses/{id}/activations/{aid}` | Aktivierung freigeben | Verwaltung |
| `POST /licenses/` | Lizenz anlegen (Programm, Produkt, Nutzer-Grenze, Dauer, Kundenkontext) | Bereitstellung, Verwaltung |
| `POST /licenses/trials` | Trial vergeben | Verwaltung |
| `PUT /licenses/{id}` | Felder ändern (Altweg sperren/verlängern) | Connector, Verwaltung |
| `POST /licenses/{id}/{suspend\|unsuspend\|extend\|revoke}` | Lebenszyklus, `Idempotency-Key` (Connector: `kc:<Auftrags-ID>`) | Connector (`lifecycle`, Widerruf = `terminate`), Verwaltung |
| `POST /licenses/{id}/entitlement` | Plan/Module/Kundengrenze setzen (Entitlement-Version) | Verwaltung |
Fehlerabbildung (`admin.ts`): 401/403 → `AUTH_FAILED`, 404 → `NOT_FOUND`, 409 → `CONFLICT`, 400/422 → `INVALID_INPUT` (Text aus `detail`), 429 → `RATE_LIMITED`, sonst `UPSTREAM_ERROR`; Zeitüberschreitung 15 s → `TIMEOUT`.
## 4. Abbildung auf den Ressourcen-Vertrag (anonymisiertes Beispiel)
Rohdaten (gekürzt, Werte erfunden):
```json
{ "id": 4711, "program_id": 3, "product_id": 12, "license_key": "PREMIUM-XXXX-…", "user_limit": 5, "duration_type": "YEAR",
"starts_at": "2026-01-10T09:00:00Z", "expires_at": "2027-01-10T09:00:00Z", "is_active": true, "status": "active",
"plan_key": "premium", "modules": ["backup"], "customer_limit": null, "activations": [{ "hardware_id": "abcd…", "activated_at": "…", "last_seen_at": "…" }] }
```
Normalisiert (`mapLicense`): `externalRef = "4711"`, `type = license`, Name = Programm + Produkt + **maskierter** Schlüssel (`PREM…XXXX`), `state` = `suspended` (inaktiv/gesperrt/widerrufen/blockiert) | `expired` (Status oder Ablauf < jetzt) | `active`, `validFrom/validUntil` in UTC, `limits.users`, Details (Programm, Produkt, Plan, Module, Kundengrenze, Add-on-Kennzeichen, Trial, Aktivierungen mit maskierter Hardware-ID). Der Klartext-Schlüssel wird nie gespeichert, nur auf Abruf (`reveal`, berechtigt, auditiert) angezeigt.
## 5. Alte Lückenliste (26.09.) – Stand heute
| Lücke damals | Stand |
|---|---|
| GET /programs und /licenses ohne Authentisierung (Schlüssel lesbar) | behoben im Lizenzsystem (Auth Pflicht), Schlüssel rotiert (26.09.) |
| Dienst als root auf 0.0.0.0 | behoben (systemd-Dienst mit eigenem Benutzer, nur 127.0.0.1, gehärtet) |
| CORS `*` | im aktuellen Licensing-Source zu prüfen (#114) – hier nicht belegt |
| Keine Health-Route | `/health`, `/ready` vorhanden |
| Kein Service-Token | Service-Tokens mit Scopes vorhanden – **Live-Verbindung noch nicht umgestellt** (#60) |
| Sperren/Verlängern nur per PUT, Laufzeit approximiert | Lebenszyklus-Endpunkte mit Idempotenz, explizites Ablaufdatum |
| Eine Aktivierung je Lizenz | mehrere Aktivierungen (Aktivierungslimit), Freigabe einzeln |
| Naive Ortszeit | `utc_timestamps` |
| Keine Kundendaten am Provider | `customer_info` bei Anlage; Änderungen (Kundenname, Inhaber-Name/-E-Mail) werden per Auftrag `customer.provider_sync` nachgezogen, Löschanspruch leert Name/Ansprechpartner/E-Mail/Kundennummer (`PUT /licenses/{id}`, #64). Unveränderlich beim Anbieter und bewusst nicht gelöscht: Quelle, Bestell- und Vertragsnummer (keine direkten Personendaten; Aufbewahrung) |
Abnahme gegen den aktuellen Licensing-Source (Schema-/Endpunktvergleich) erst nach dem Abgleich Server ↔ Forge (#114). Testabdeckung im KC: `packages/connector-licensing/test` (18 Tests, gegen nachgebildete Antworten; keine echten Schlüssel in Fixtures).

53
docs/connector-plesk.md Normal file
View file

@ -0,0 +1,53 @@
# Plesk-Connector
## Umsetzungsstand (05.10.2026)
Paket `packages/connector-plesk`, gebaut nach der Plesk-Dokumentation (XML-API, Plesk Obsidian 18), getestet gegen einen Nachbau (`test/fake.ts`) **und am 05.10.2026 live gegen Plesk Obsidian 18.0.81** (Debian 13, Testserver) vom Kundencenter-Server aus. Zugang: Plesk-Adresse mit Port (meist `https://host:8443`) + **Secret Key**.
### Einrichtung
1. Auf dem Plesk-Server als root: `plesk bin secret_key -c -ip-address <IP des Kundencenter-Servers> -description Kundencenter` → Schlüssel kopieren. Er ist an diese IP gebunden und hat **Administratorrechte** (verschlüsselt gespeichert, nur Superadmins).
2. Kundencenter → Einstellungen → Verbindungen → „Plesk (Webhosting)“: Adresse, Secret Key; bei selbstsigniertem Zertifikat (Port 8443 üblich) den SHA-256-Fingerabdruck.
3. Nur für die Bereitstellung neuer Konten: **IP-Adresse für neue Abonnements** (gemeinsame IPv4) und **Domain für neue Abonnements** (z. B. `kunden.example.de`).
### Abbildung
| Kundencenter | Plesk | Bemerkung |
|---|---|---|
| Hosting-Konto (Ressource) | **Abonnement** (`webspace`) | `externalRef` = Abonnement-ID. Name „domain · login des Besitzers“. |
| Kontaktdaten bei der Übernahme | Plesk-**Kunde** (Besitzer des Abonnements) | Je Abonnement ein Eintrag. Hat ein Kunde mehrere Abonnements, das zweite bei der Übernahme **mit dem bereits angelegten Kunden verknüpfen**. Abonnements des Administrators haben keinen Kunden. |
| Produktvorlage | **Service-Plan** | `plan:<id>`, fest vorgegeben; Bereitstellungsparameter `planId` (+ `planName` zur Anzeige). |
| Zustand | `gen_info/status` | 0 aktiv, 4 Sicherung läuft (aktiv), 16/32/64 gesperrt, 256 abgelaufen. |
| Limits / Nutzung | `limits` (Plan), `stat`, `real_size` | Gleiche Schlüssel wie beim KeyHelp-Connector (`disk_space`, `traffic`, `domains`, `subdomains`, `email_accounts`, `databases`, `ftp_users`); -1 = unbegrenzt; `expiration` → „gültig bis“. |
### Funktionen
- **Lesen/Abgleich**: Health mit Plesk-Version, Abonnements mit Besitzer, Plan, Limits, Nutzung (3 Abfragen, unabhängig von der Anzahl).
- **Kunden übernehmen**, **Service-Pläne übernehmen** (Produkte → Aus Verbindung übernehmen).
- **Bereitstellung** (Bestellung): Kunde mit Login `kc` + Ziffern der Vertragsnummer und Vermerk „Kundencenter K-… V-…“, dann Abonnement `kc<Nr>.<Domain für neue Abonnements>` auf dem Plan. Wiederholung findet Kunde (am Vermerk) und Abonnement (am Besitzer) wieder statt doppelt anzulegen. Passwörter (Kunde, FTP) werden zufällig erzeugt und **nie gespeichert**; Zugang über den Panel-Login.
- **Aktionen**: Sperren/Entsperren (Status 16/0), Planwechsel (`switch-subscription`), Löschen des Abonnements (Kunde bleibt; nie automatisch wiederholt), Passwort des Besitzers neu setzen.
- **Panel-Login**: Einmal-Sitzung für den Besitzer (`server/create_session` → `rsession_init.php`), nie gespeichert.
- **Unterobjekte** (Freigabe pro Produkt/Ressource wie bei KeyHelp): Domains (weitere Sites/Subdomains anlegen und löschen; Hauptdomain geschützt), Postfächer (anlegen, Passwort/Größe, löschen), Datenbanken (MySQL mit gleichnamigem Benutzer, Passwort, löschen), FTP-Benutzer (anlegen, Passwort/Verzeichnis, löschen; `/www/` aus der Oberfläche wird zu `/httpdocs`). Vor jeder Änderung wird geprüft, dass das Objekt zum Abonnement gehört; Anlegen ist wiederholbar, Löschen idempotent. Domain-Einstellungen (PHP, Let’s Encrypt) bitte im Plesk-Panel ändern.
### Sicherheit
- Alle Werte werden in XML maskiert (keine Element-Injektion); Antworten mit DOCTYPE/ENTITY werden abgelehnt (kein XXE).
- Der Secret Key steht nur im Header `KEY`, nie im Paket. Lesende Pakete werden bei 5xx/Netzfehler wiederholt, schreibende nie automatisch.
### Live-Prüfung (Plesk 18.0.81, 05.10.2026)
| Punkt | Ergebnis |
|---|---|
| Secret Key im Header `KEY`, Zertifikat per Fingerabdruck | ✅ bestätigt |
| Leerer `<filter/>` liefert alles, 1013 = nicht gefunden | ✅ bestätigt |
| Elementreihenfolge `customer/add`, `webspace/add` | ✅ bestätigt (Bereitstellung + Wiederholung ohne Doppelanlage) |
| `subscriptions/plan-guid`, effektive `limits`, `expiration` | ✅ bestätigt |
| Größen in Byte, `cr_date` als Datum | ✅ bestätigt |
| `server/get`: Reihenfolge | ❌ war `stat, gen_info` → Plesk verlangt **`gen_info` vor `stat`** (behoben) |
| Panel-Login (`create_session`) | ❌ Sitzung ist an `user_ip` gebunden; mit 127.0.0.1 landet der Kunde auf der Anmeldeseite → **IP des Browsers wird übergeben** (SDK: `loginUrl(ctx, ref, { userIp })`, API: `clientIp(req)`), danach ✅ |
| `site/get`, `mail/get_info`, `database/get-db`, `ftp-user/get` | ✅ bestätigt; bei 0 Treffern liefert Plesk ein leeres `<result>` ohne `id` → wird ausgefiltert (behoben) |
| Sperren/Entsperren, Planwechsel, Passwort, Löschen | ✅ bestätigt (Zielzustand, Wiederholung unschädlich) |
| Mandantentrennung bei Unterobjekten | ✅ bestätigt |
| Unterobjekte ändern (`site/add·del`, `mail/create·update·remove`, `database/add-db·add-db-user·set-db-user·del-db`, `ftp-user/add·set·del`) | ✅ bestätigt; Eigenheiten: `set-db-user` erwartet `<id>` direkt (kein `<filter>`), Element heißt `create-non-existent` (für neue FTP-Verzeichnisse nötig), Plan-/Lizenzlimits kommen als Fehler **1024** (jetzt Ablehnung statt Wiederholung), **`mail/create` legt das Postfach an und meldet erst danach einen Größenfehler** → Connector rollt zurück |
Hinweis: Mit der kostenlosen Edition „Web Admin SE“ sind höchstens 3 Kunden/3 Domains möglich; für echten Betrieb ist eine Plesk-Lizenz mit Kundenverwaltung (z. B. Web Pro/Web Host) nötig.
### Noch nicht umgesetzt
Neue Service-Pläne aus dem Kundencenter anlegen, Domain-Einstellungen (PHP-Version, Let’s Encrypt), Weiterleitungen/Aliase von Postfächern, SSL-Zertifikate, DNS, Reseller, mehrere Abonnements je Bestellung.
### Testen ohne eigenen Server
Plesk bietet ein offizielles Docker-Image (`plesk/plesk`) und eine kostenlose Testlizenz (14 Tage). Das Skript für den Live-Test liegt nicht im Repo (nutzt echte Zugangsdaten); Ablauf: read → provision → actions → sso → children → cleanup.

View file

@ -28,7 +28,8 @@ Status: geplant → wird ausgeführt → erfolgreich | wird wiederholt → manue
- `lifecycle`: Sperren/Entsperren/Verlängern über die Endpunkte `/licenses/{id}/suspend|unsuspend|extend` (Zielzustand, protokolliert); sonst Rückfall auf `PUT`.
- Zustand berücksichtigt `is_active`, `blocked`, `status`, `suspended_at`, `revoked_at` und Ablauf. Bei `utc_timestamps` werden Zeiten als UTC gelesen, sonst als Ortszeit.
- Anlage (`lifecycle.create`) mit `product_id` (Plan/Edition des Lizenzsystems); Produkt und Präfix dürfen nie stillschweigend verloren gehen (Antwort wird geprüft).
- KeyHelp, Plesk: **offen** (keine Testzugänge; siehe Plane).
- `keyhelp` – KeyHelp-Panel, siehe `docs/connector-keyhelp.md`.
- `plesk` – Plesk-Panel über die XML-API (Abonnement = Hosting-Konto), siehe `docs/connector-plesk.md`. Ungetestet gegen eine echte Instanz.
## Zugangsdaten
Secrets werden pro Verbindung mit AES-256-GCM verschlüsselt (`connector_instances.secrets_enc`), nur Superadmins dürfen Verbindungen anlegen/ändern, die UI zeigt sie nie wieder an, das Audit-Protokoll maskiert sie.

112
docs/datenmodell.md Normal file
View file

@ -0,0 +1,112 @@
# Datenmodell und Statusautomaten
Stand: 06.10.2026, Migrationen 001–041. Das Diagramm ist aus einer frisch migrierten Datenbank abgeleitet (`information_schema`: Tabellen und Fremdschlüssel), nicht aus Annahmen. Einstellungs-Einzeiler (`*_settings` mit `id = 1`) sind nur in der Liste unten aufgeführt.
## ER-Diagramm (Kern)
```mermaid
erDiagram
organizations ||--o{ memberships : hat
users ||--o{ memberships : ist
organizations ||--|| billing_profiles : Rechnungsprofil
users ||--o{ sessions : ""
users ||--o| mfa_totp : ""
users ||--o{ recovery_codes : ""
users ||--o{ user_tokens : "Einladung/Reset"
products ||--o{ product_versions : Version
product_versions ||--o{ product_term_prices : Laufzeitstaffel
tax_rates ||--o{ product_versions : ""
connector_instances ||--o{ products : "Bereitstellung über"
organizations ||--o{ orders : ""
orders ||--o{ order_items : ""
product_versions ||--o{ order_items : ""
order_items ||--|| contracts : "erzeugt"
organizations ||--o{ contracts : ""
product_versions ||--o{ contracts : ""
contracts }o--o| resources : "bereitgestellt als"
contracts ||--o{ contract_renewal_tokens : "Behalten/Kündigen-Link"
connector_instances ||--o{ resources : ""
organizations ||--o{ resources : ""
resources ||--o| panel_credentials : ""
organizations ||--o{ invoices : ""
invoices ||--o{ invoice_items : ""
contracts ||--o{ invoice_items : "abgerechnet in"
invoices |o--o| invoices : "Storno von"
contracts ||--o{ invoice_billing_periods : "Periode"
invoices ||--o{ invoice_billing_periods : ""
organizations ||--o{ tickets : ""
tickets ||--o{ ticket_messages : ""
ticket_messages ||--o{ ticket_attachments : ""
tickets }o--o| resources : "bezieht sich auf"
tickets }o--o| domain_records : "bezieht sich auf"
tickets ||--o| ticket_discord_threads : "Discord-Kanal"
inbox_messages }o--o| tickets : "zugeordnet / Vorschlag"
inbox_messages }o--o| users : "Absender / Vorschlag"
```
Nicht im Diagramm (eigenständig oder nur Protokoll): `audit_events` (Hash-Kette, unveränderlich per Trigger), `audit_settings`, `audit_retention_checkpoints`, `jobs` (Queue, ADR 0003), `mail_log`, `mail_templates`, `mail_sender_profiles`, `domain_records`/`domain_settings`/`domain_tlds` (Domain-Aufstellung, Bezug zu Organisation/Ressource über Spalten), `license_state`/`license_signing_keys` (eigene Lizenz), `number_sequences`/`customer_sequences` (Nummernkreise), `system_alerts`/`system_heartbeats` (Betriebsalarme), `schema_migrations`/`schema_migrations_dirty`, Einstellungen: `settings`, `company_settings`, `smtp_settings`, `imap_settings`, `discord_settings`, `discord_oauth_states`, `backup_settings`, `backup_targets`.
## Rechnungen (Eigenbau, ersetzt den früheren Begriff „Rechnungsspiegel“)
Rechnungen werden im Kundencenter selbst erzeugt (#5, keine externe Rechnungssoftware):
- `invoices`: Nummer erst beim Ausstellen (Nummernkreis `invoice`), Summen in Cent, **eingefrorene Absender-/Empfängerdaten** (`seller_snapshot_json`, `buyer_snapshot_json`) ab dem Ausstellen; Storno als eigene Rechnung mit negativen Beträgen (`cancels_invoice_id` ↔ `cancelled_by_invoice_id`).
- `invoice_items`: Positionen mit Steuersatz und Rabatt je Position, optional Bezug auf einen Vertrag.
- `invoice_billing_periods`: welche Vertragsperiode mit welcher Rechnung abgerechnet ist (Abrechnungslauf, #50).
- Verträge tragen den **Preis-Snapshot** (`price_snapshot_json`) aus der Bestellung; spätere Katalogänderungen wirken nicht rückwirkend.
## Statusautomaten
### Bestellung (`orders.status`) – `platform/statemachine.ts`, nur über `transition()`
| von \ Ereignis | approve | reject | cancel | start_provisioning | complete | fail | retry |
|---|---|---|---|---|---|---|---|
| pending_approval | approved | rejected | cancelled | | | | |
| approved | | | cancelled | provisioning | | | |
| provisioning | | | | | completed | failed | |
| failed | | | cancelled | | | | provisioning |
Endzustände ohne Ausgang: `completed`, `rejected`, `cancelled`. Nebenwirkungen: Bei der Anlage/Freigabe entstehen die Verträge im Zustand `pending` (mit Preis-Snapshot); `complete` aktiviert sie (`activate`); `fail` speichert `failure_note` und markiert unklare Provider-Ergebnisse (`failure_ambiguous`) – dann erst Abgleich, kein blinder Neuversuch. Test: `packages/platform/test/logic.test.ts` „Bestellung: erlaubte Übergänge“ und „alle anderen Übergänge sind verboten“ (alle Kombinationen).
### Vertrag (`contracts.status`)
| von \ Ereignis | activate | suspend | unsuspend | cancel | expire | fail |
|---|---|---|---|---|---|---|
| pending | active | | | cancelled | | failed |
| active | | suspended | | cancelled | expired | |
| suspended | | | active | cancelled | expired | |
Kündigung durch Kunden setzt zunächst nur `cancel_requested_at`/`cancel_effective_at`; der Vertragslauf im Worker (`processContractLifecycle`) beendet bzw. verlängert zum Laufzeitende (`renewal = auto`). Rückabwicklung: kein Weg zurück aus `cancelled`/`expired`/`failed` – ein neuer Vertrag entsteht nur über eine neue Bestellung. Test: `logic.test.ts` „Vertrag: alle Übergänge vollständig geprüft“, Laufzeit/Kündigung ebenda.
### Rechnung (`invoices.status`)
| von | Aktion | nach | Bedingung / Nebenwirkung |
|---|---|---|---|
| draft | Positionen speichern | draft | nur unter Zeilensperre im Status draft (#95) |
| draft | ausstellen | open | Firmenstammdaten vollständig, ≥ 1 Position; Nummer + Snapshots, Mail an Rechnungsadresse |
| draft | löschen | – | gibt Abrechnungsperioden frei |
| open | als bezahlt markieren | paid | |
| open | stornieren | cancelled | neue Storno-Rechnung (open) mit negativen Beträgen; Perioden bleiben belegt bis zur Freigabe |
Verboten (409/403): Positionen ändern außer im Entwurf, ausgestellte Rechnung löschen, doppelt ausstellen/stornieren/bezahlen. Tests: `apps/api/test/invoices.test.ts` (inkl. Nebenläufigkeit), `billing.test.ts`.
### Ressource (`resources.state`, vom Anbieter abgeglichen)
`active`, `suspended`, `expired`, `error`, `unknown` – kein eigener Automat: der Zustand spiegelt den Anbieter (Connector-Abgleich). Aktionen (sperren, entsperren, verlängern, löschen) laufen als Jobs; unklare Ergebnisse → `needs_review` und Abgleich statt Annahme.
### Ticket (`tickets.status`)
`open`, `pending_customer`, `pending_staff`, `resolved`, `closed`. Automatisch: Kundenantwort (Web, Mail mit Bezug, Discord) → `pending_staff`; Personalantwort → `pending_customer`; interne Notiz ändert nichts. Personal (`tickets.write`) kann den Status frei setzen; `closed` ist für Antworten gesperrt (409, neues Ticket nötig). Kein fester Automat – bewusst, weil Support-Abläufe flexibel bleiben sollen.
### Posteingang (`inbox_messages.status`)
`unmatched` → `matched` (an Ticket angehängt) | `created` (neues Ticket) | `ignored`. Nur aus `unmatched`, atomar (Doppelklick erzeugt kein zweites Ticket, #107).
### Auftrag (`jobs.status`)
`scheduled` → `running` → `succeeded` | `retrying` (→ `running`) | `failed` | `needs_review` | `partial`/`waiting_external` (Connector-spezifisch). Absturz: `running` ohne Herzschlag → `retrying`, destruktiv → `needs_review` (`security.test.ts`).

54
docs/design/README.md Normal file
View file

@ -0,0 +1,54 @@
# Designsystem und Seitenstruktur
Stand: 06.10.2026. Quelle der Wahrheit ist der Code: Tokens in `apps/web/src/app/globals.css`, Bausteine in `apps/web/src/components/ui.tsx`, Icons in `components/Icon.tsx` (Lucide-Pfade, keine Emojis). Stil „FlessingLabs“ (an flessinglabs.com angelehnt, live seit #121–#127) – die frühere Calm-Cloud/KeyControl-Palette ist abgelöst und wird nicht wiederhergestellt.
- `sitemap.md` – Seitenlandkarte (öffentlich, Kunde, Personal) und Kernabläufe
- Dieses Dokument – Tokens, Komponenten, Zustände, Barrierefreiheit
## Tokens (CSS-Variablen)
| Gruppe | Hell | Dunkel | Verwendung |
|---|---|---|---|
| Hintergrund/Fläche | `--bg #f5f7fb`, `--surface #fff`, `--surface-2 #eef1f7` | `#05060a`, `#0b0d14`, `#121622` | Seite, Karten, abgesetzte Flächen |
| Text | `--text #111522`, `--muted #5b6475` | `#f5f7ff`, `#9aa4b5` | Fließtext, Nebeninfo (≥ 4,5:1 auf Fläche) |
| Akzent | `--accent #1a5fd0`, `--accent2 #0a7ea8`, `--focus #1a5fd0` | `#4d9dff`, `#20d4f5`, `#20d4f5` | Links, primäre Aktionen, Fokusring |
| Rahmen | `--border #e3e7ef`, `--border-strong #7a8599` | `rgba(255,255,255,.08)`, `#5f6b7c` | Trennlinien; **Eingabefelder immer `--border-strong`** (3:1 für UI-Komponenten) |
| Status | `--ok/-bg`, `--info/-bg`, `--warn/-bg`, `--err/-bg`, `--lock/-bg` | dunkle Varianten | Badges, Hinweise; nie nur Farbe – immer Symbol + Text |
| Navigation | `--nav-bg #0b0d14` … | `#05060a` … | dunkle Seitenleiste in beiden Modi |
| Marke | `--brand-gradient` (#20d4f5 → #2584ff → #7028ff), `--brand-btn` | gleich | Logo, primärer Knopf |
| Form | `--radius 12px`, `--radius-lg 16px`, `--radius-sm 10px` | | |
| Abstände | `--s1 4`, `--s2 8`, `--s3 16`, `--s4 24`, `--s5 40` px | | |
| Schrift | Geist / Geist Mono (`next/font`), Fallback system-ui | | |
Hell/Dunkel folgt `prefers-color-scheme`; die manuelle Wahl (ThemeToggle) setzt `data-theme` und wird gemerkt.
## Bausteine (`components/ui.tsx`)
- `Alert kind=err|warn|ok|info` – Meldungen; `err` mit `role="alert"`, sonst `role="status"`.
- `Field id label hint` – Label immer sichtbar und verknüpft, Hinweis per `aria-describedby`.
- `Empty title` – Leerzustand mit Erklärung, was zu tun ist.
- Status-Badges (`Status`, `ResState`, `JobStatus`, `OrderStatusBadge`, `ContractStatusBadge`, `InvoiceStatusBadge`, `TicketStatusBadge`) – Symbol (`aria-hidden`) + Klartext.
- `TableCards` – Tabellen werden auf schmalen Bildschirmen (≤ 800 px) automatisch zu Karten (Spaltenkopf als Label).
- `SecretField` – Geheimnisse nur auf ausdrücklichen Abruf, Kopieren ohne Anzeige.
- Formatierer: `fmt` (Datum+Zeit), `fmtDate`, `fmtDay` (Kalendertag in UTC), `eur` (Cent → Euro).
## Zustände (Pflicht für jede Seite mit Daten)
| Zustand | Vorgabe | Beispiel |
|---|---|---|
| Laden | Text „Wird geladen …“ mit `role="status"` (kein reiner Spinner) | Rechnungen → Fällig |
| Leer | `Empty` mit Titel und nächstem Schritt | „Keine fälligen Perioden“ |
| Fehler | `Alert kind="err"` mit der Meldung der API (`errMsg`), Formularwerte bleiben erhalten | alle Formulare |
| Offline / Server nicht erreichbar | `errMsg` liefert „Der Server ist nicht erreichbar. Bitte später erneut versuchen.“ | API-Client |
| Teilfehler / veraltet | `Alert kind="warn"` + Badge „Veraltet“, es wird der zuletzt bekannte Stand gezeigt | Ressourcen (Anbieter nicht erreichbar) |
| Gesperrt / Lizenz nötig | Badge `lock` bzw. Hinweis „nur mit Lizenz“ mit Link zu Einstellungen → Lizenz | Testmodus-Hinweisleiste |
| Betriebsalarm | Karte „Betriebsalarme“ im Dashboard (`role="alert"`) | #38 |
## Barrierefreiheit (WCAG 2.2 AA)
- Kontrast Text ≥ 4,5:1, UI-Komponenten ≥ 3:1 (Eingaben mit `--border-strong`); geprüft automatisch per axe in `apps/e2e` (Login, Dashboard, Kundenliste, Kunden-Dashboard; hell/Desktop und dunkel/360 px).
- Tastatur: sichtbarer Fokus (`--focus`), logische Reihenfolge, `autoFocus` nur auf dem ersten Feld eines Formulars, Enter sendet. E2E prüft Fokus/Tab/Enter auf der Anmeldung.
- Mobil: Mindestgröße für Bedienelemente 44 px (untere Navigation 56 px), Navigation unten mit „Mehr“-Menü; kein horizontales Scrollen bei 360 px.
- Bewegung: keine automatischen Animationen mit Bedeutung; Statusänderungen als Text.
Automatische Prüfung: `ops/test/run-e2e.sh` (CI-Job `e2e`, #39). Neue Seiten in `apps/e2e/tests` aufnehmen.

Some files were not shown because too many files have changed in this diff Show more