diff --git a/.forgejo/workflows/ci.yml b/.forgejo/workflows/ci.yml new file mode 100644 index 0000000..195e717 --- /dev/null +++ b/.forgejo/workflows/ci.yml @@ -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 diff --git a/.gitignore b/.gitignore index d2607f9..48f3b02 100644 --- a/.gitignore +++ b/.gitignore @@ -7,3 +7,5 @@ dist *.log *.tsbuildinfo .pnpm-store/ +apps/e2e/test-results/ +apps/e2e/playwright-report/ diff --git a/README.md b/README.md index 9f37bb4..3bc9d33 100644 --- a/README.md +++ b/README.md @@ -101,6 +101,37 @@ API-Module liegen in `apps/api/src/modules/` 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. diff --git a/apps/api/src/cli/index.ts b/apps/api/src/cli/index.ts index 9207405..a1babda 100644 --- a/apps/api/src/cli/index.ts +++ b/apps/api/src/cli/index.ts @@ -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') { diff --git a/apps/api/src/cli/migrate.ts b/apps/api/src/cli/migrate.ts index 1d07980..0e0b91b 100644 --- a/apps/api/src/cli/migrate.ts +++ b/apps/api/src/cli/migrate.ts @@ -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 { - 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 { + 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(); } diff --git a/apps/api/src/core/accounts.ts b/apps/api/src/core/accounts.ts index 08731d7..39e39ec 100644 --- a/apps/api/src/core/accounts.ts +++ b/apps/api/src/core/accounts.ts @@ -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 { 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 { 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 }; diff --git a/apps/api/src/core/policy.ts b/apps/api/src/core/policy.ts index dd35dce..5f3e6a7 100644 --- a/apps/api/src/core/policy.ts +++ b/apps/api/src/core/policy.ts @@ -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 = { @@ -7,6 +8,7 @@ const STAFF: Record = { 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 = { owner: ['org.read', 'org.members.read', 'org.members.invite'], diff --git a/apps/api/src/modules/analytics/index.ts b/apps/api/src/modules/analytics/index.ts new file mode 100644 index 0000000..7815859 --- /dev/null +++ b/apps/api/src/modules/analytics/index.ts @@ -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.', + ], + }; + }); + }, +}; diff --git a/apps/api/src/modules/audit/index.ts b/apps/api/src/modules/audit/index.ts index cac1e3c..c14edd0 100644 --- a/apps/api/src/modules/audit/index.ts +++ b/apps/api/src/modules/audit/index.ts @@ -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', diff --git a/apps/api/src/modules/customers/index.ts b/apps/api/src/modules/customers/index.ts index 89ace95..663b589 100644 --- a/apps/api/src/modules/customers/index.ts +++ b/apps/api/src/modules/customers/index.ts @@ -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 = { 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); }); diff --git a/apps/api/src/modules/domains/index.ts b/apps/api/src/modules/domains/index.ts index 5783b57..75ef4f6 100644 --- a/apps/api/src/modules/domains/index.ts +++ b/apps/api/src/modules/domains/index.ts @@ -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'] } }, diff --git a/apps/api/src/modules/domains/logic.ts b/apps/api/src/modules/domains/logic.ts index 79de065..1f00dac 100644 --- a/apps/api/src/modules/domains/logic.ts +++ b/apps/api/src/modules/domains/logic.ts @@ -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(); - 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): { 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 = { de: 'https://rdap.denic.de/' }; -let boot: { at: number; map: Map } | null = null; -async function rdapBase(tld: string): Promise { - 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(); - 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 { - 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 { - 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'; diff --git a/apps/api/src/modules/identity/index.ts b/apps/api/src/modules/identity/index.ts index ffbd351..996e0ea 100644 --- a/apps/api/src/modules/identity/index.ts +++ b/apps/api/src/modules/identity/index.ts @@ -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' }; }); }, diff --git a/apps/api/src/modules/index.ts b/apps/api/src/modules/index.ts index f0f59d6..7def335 100644 --- a/apps/api/src/modules/index.ts +++ b/apps/api/src/modules/index.ts @@ -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]; diff --git a/apps/api/src/modules/invoices/index.ts b/apps/api/src/modules/invoices/index.ts index 36613c3..d03ab9e 100644 --- a/apps/api/src/modules/invoices/index.ts +++ b/apps/api/src/modules/invoices/index.ts @@ -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): { 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 = { 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 = { 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)[k] !== undefined) { sets.push(`${col} = ?`); params.push((b as Record)[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 }; }); diff --git a/apps/api/src/modules/mail/index.ts b/apps/api/src/modules/mail/index.ts index c0503b6..548d26d 100644 --- a/apps/api/src/modules/mail/index.ts +++ b/apps/api/src/modules/mail/index.ts @@ -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 }; diff --git a/apps/api/src/modules/orders/index.ts b/apps/api/src/modules/orders/index.ts index 978ad80..167c2f0 100644 --- a/apps/api/src/modules/orders/index.ts +++ b/apps/api/src/modules/orders/index.ts @@ -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 { 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 { + 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> }[] = []; + 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' }; }); diff --git a/apps/api/src/modules/resources/index.ts b/apps/api/src/modules/resources/index.ts index 52fc74e..facd64f 100644 --- a/apps/api/src/modules/resources/index.ts +++ b/apps/api/src/modules/resources/index.ts @@ -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 = (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(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); diff --git a/apps/api/src/modules/status/index.ts b/apps/api/src/modules/status/index.ts new file mode 100644 index 0000000..027efa7 --- /dev/null +++ b/apps/api/src/modules/status/index.ts @@ -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 }; + }); + }, +}; diff --git a/apps/api/src/modules/system/index.ts b/apps/api/src/modules/system/index.ts index 9336775..ae3ba70 100644 --- a/apps/api/src/modules/system/index.ts +++ b/apps/api/src/modules/system/index.ts @@ -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 }; }); }, }; diff --git a/apps/api/src/modules/tickets/index.ts b/apps/api/src/modules/tickets/index.ts index f7bcc70..96f2c62 100644 --- a/apps/api/src/modules/tickets/index.ts +++ b/apps/api/src/modules/tickets/index.ts @@ -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 = >(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, key: string, correlationId: string) => enqueue('discord.notify', { event, ...extra }, { idempotencyKey: key, correlationId }); -const mailTo = (to: string, template: string, vars: Record, key: string, correlationId: string) => enqueue('mail.template', { to, key: template, vars }, { idempotencyKey: key, correlationId }); +const mailTo = (to: string, template: string, vars: Record, 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 }; }); diff --git a/apps/api/src/ops/backup.ts b/apps/api/src/ops/backup.ts index be408c1..13fd959 100644 --- a/apps/api/src/ops/backup.ts +++ b/apps/api/src/ops/backup.ts @@ -33,7 +33,8 @@ function run(cmd: string, args: string[], o: { env?: Record; 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 (await conn.query(sql))[0] as any[]; diff --git a/apps/api/src/ops/watchdog.ts b/apps/api/src/ops/watchdog.ts new file mode 100644 index 0000000..c425381 --- /dev/null +++ b/apps/api/src/ops/watchdog.ts @@ -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 { + 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(); +} diff --git a/apps/api/src/server.ts b/apps/api/src/server.ts index 1bd7274..300d721 100644 --- a/apps/api/src/server.ts +++ b/apps/api/src/server.ts @@ -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(); } diff --git a/apps/api/test/analytics.test.ts b/apps/api/test/analytics.test.ts new file mode 100644 index 0000000..6531c17 --- /dev/null +++ b/apps/api/test/analytics.test.ts @@ -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 = {}; + +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); + }); +}); diff --git a/apps/api/test/billing.test.ts b/apps/api/test/billing.test.ts new file mode 100644 index 0000000..ec4bbf6 --- /dev/null +++ b/apps/api/test/billing.test.ts @@ -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 + }); +}); diff --git a/apps/api/test/drift.test.ts b/apps/api/test/drift.test.ts new file mode 100644 index 0000000..43ff4c6 --- /dev/null +++ b/apps/api/test/drift.test.ts @@ -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 + }); +}); diff --git a/apps/api/test/global-setup.ts b/apps/api/test/global-setup.ts index 39d8e3a..3473584 100644 --- a/apps/api/test/global-setup.ts +++ b/apps/api/test/global-setup.ts @@ -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'); diff --git a/apps/api/test/invoices.test.ts b/apps/api/test/invoices.test.ts index 9a06b0d..921e21e 100644 --- a/apps/api/test/invoices.test.ts +++ b/apps/api/test/invoices.test.ts @@ -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', () => { diff --git a/apps/api/test/license.test.ts b/apps/api/test/license.test.ts new file mode 100644 index 0000000..d072450 --- /dev/null +++ b/apps/api/test/license.test.ts @@ -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) => { + 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 = {}) => ({ 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) => 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); } + }); +}); diff --git a/apps/api/test/mailbox.test.ts b/apps/api/test/mailbox.test.ts new file mode 100644 index 0000000..c87f74e --- /dev/null +++ b/apps/api/test/mailbox.test.ts @@ -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, 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 ', 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]); + }); +}); diff --git a/apps/api/test/migrate.test.ts b/apps/api/test/migrate.test.ts new file mode 100644 index 0000000..f90414a --- /dev/null +++ b/apps/api/test/migrate.test.ts @@ -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) => { 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/); + }); +}); diff --git a/apps/api/test/monitor.test.ts b/apps/api/test/monitor.test.ts new file mode 100644 index 0000000..2c1a674 --- /dev/null +++ b/apps/api/test/monitor.test.ts @@ -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); + }); +}); diff --git a/apps/api/test/order-domains.test.ts b/apps/api/test/order-domains.test.ts new file mode 100644 index 0000000..c866401 --- /dev/null +++ b/apps/api/test/order-domains.test.ts @@ -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 + }); +}); diff --git a/apps/api/test/orders.test.ts b/apps/api/test/orders.test.ts index 8249a31..6ca1bae 100644 --- a/apps/api/test/orders.test.ts +++ b/apps/api/test/orders.test.ts @@ -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'); + }); +}); diff --git a/apps/api/test/registration.test.ts b/apps/api/test/registration.test.ts new file mode 100644 index 0000000..a5af9f1 --- /dev/null +++ b/apps/api/test/registration.test.ts @@ -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>['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 = {}) => 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); + }); +}); diff --git a/apps/api/test/security.test.ts b/apps/api/test/security.test.ts new file mode 100644 index 0000000..f7c1cb8 --- /dev/null +++ b/apps/api/test/security.test.ts @@ -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'"); + }); +}); diff --git a/apps/api/test/status.test.ts b/apps/api/test/status.test.ts new file mode 100644 index 0000000..a9430aa --- /dev/null +++ b/apps/api/test/status.test.ts @@ -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'); + }); +}); diff --git a/apps/api/test/worker.test.ts b/apps/api/test/worker.test.ts new file mode 100644 index 0000000..2cb7fb6 --- /dev/null +++ b/apps/api/test/worker.test.ts @@ -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(); + }); +}); diff --git a/apps/e2e/package.json b/apps/e2e/package.json new file mode 100644 index 0000000..a3f2616 --- /dev/null +++ b/apps/e2e/package.json @@ -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" + } +} diff --git a/apps/e2e/playwright.config.ts b/apps/e2e/playwright.config.ts new file mode 100644 index 0000000..ddee55f --- /dev/null +++ b/apps/e2e/playwright.config.ts @@ -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; +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 }, + ], +}); diff --git a/apps/e2e/setup-db.ts b/apps/e2e/setup-db.ts new file mode 100644 index 0000000..f49d59f --- /dev/null +++ b/apps/e2e/setup-db.ts @@ -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(); diff --git a/apps/e2e/tests/abnahme.spec.ts b/apps/e2e/tests/abnahme.spec.ts new file mode 100644 index 0000000..642df28 --- /dev/null +++ b/apps/e2e/tests/abnahme.spec.ts @@ -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(); +}); + diff --git a/apps/e2e/tests/helpers.ts b/apps/e2e/tests/helpers.ts new file mode 100644 index 0000000..07576b1 --- /dev/null +++ b/apps/e2e/tests/helpers.ts @@ -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 { + 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([]); +} diff --git a/apps/web/public/brand/fl-mark.png b/apps/web/public/brand/fl-mark.png new file mode 100644 index 0000000..50e2894 Binary files /dev/null and b/apps/web/public/brand/fl-mark.png differ diff --git a/apps/web/src/app/(app)/admin/benutzer/page.tsx b/apps/web/src/app/(app)/admin/benutzer/page.tsx index 5c058dd..9ea6366 100644 --- a/apps/web/src/app/(app)/admin/benutzer/page.tsx +++ b/apps/web/src/app/(app)/admin/benutzer/page.tsx @@ -29,7 +29,7 @@ export default function Benutzer() { {msg && {msg.t}} {open &&

Neuer Mitarbeiter

-
+

Mitarbeiter müssen bei der ersten Anmeldung 2FA einrichten.

} {resetFor &&

2FA von {resetFor.name} zurücksetzen? Alle Sitzungen des Benutzers werden beendet. Bitte nur nach Prüfung der Identität ausführen. Die Aktion wird protokolliert.

} diff --git a/apps/web/src/app/(app)/admin/domains/page.tsx b/apps/web/src/app/(app)/admin/domains/page.tsx index 2c51109..66b1f17 100644 --- a/apps/web/src/app/(app)/admin/domains/page.tsx +++ b/apps/web/src/app/(app)/admin/domains/page.tsx @@ -3,9 +3,9 @@ import Link from 'next/link'; import { DomainRecords } from '@/components/DomainRecords'; export default function Aufstellung() { - return (<> + return (

Domain-Aufstellung

Preisliste & Aufschlag

Je Domain: Einkauf (Preisliste von KCS, dort Bruttopreise inkl. USt; netto herausgerechnet) und Ihr errechneter Verkaufspreis brutto und netto. Die USt wird nicht doppelt aufgeschlagen. Damit sehen Sie, was Sie bei KCS bestellen müssen und was Sie berechnen.

- ); +
); } diff --git a/apps/web/src/app/(app)/admin/kunden/[id]/page.tsx b/apps/web/src/app/(app)/admin/kunden/[id]/page.tsx index c34bb58..fc8e21a 100644 --- a/apps/web/src/app/(app)/admin/kunden/[id]/page.tsx +++ b/apps/web/src/app/(app)/admin/kunden/[id]/page.tsx @@ -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; 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(null); const [orders, setOrders] = useState(null); const [ress, setRess] = useState(null); - const [o, setO] = useState(null); const [msg, setMsg] = useState<{ k: 'ok' | 'err' | 'warn'; t: string } | null>(null); const [confirm, setConfirm] = useState(null); const [switchTo, setSwitchTo] = useState<'private' | 'business' | null>(null); + const [o, setO] = useState(null); const [msg, setMsg] = useState<{ k: 'ok' | 'err' | 'warn'; t: string } | null>(null); const [confirm, setConfirm] = useState(null); const [switchTo, setSwitchTo] = useState<'private' | 'business' | null>(null); const [editUser, setEditUser] = useState(null); const [impersonateOpen, setImpersonateOpen] = useState(false); const [impersonateBusy, setImpersonateBusy] = useState(false); const [welcomeBusy, setWelcomeBusy] = useState(false); const load = useCallback(() => api('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('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, 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() {
} + {w &&

Kundenangaben bei Anbietern

+

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.

+
+
}

Stammdaten & Rechnungsanschrift

{o.customerType === 'business' && } @@ -75,11 +89,11 @@ export default function Kunde() {

Verträge

{can('orders.write') && Bestellung anlegen}
{contracts === null ?

Wird geladen …

: contracts.length === 0 ? :
- {contracts.map((c) => )}
Nr.ProduktLaufzeit bisStatus
{c.number}{c.productName}{c.termEnd ? fmt(c.termEnd) : 'unbefristet'}{c.cancelEffectiveAt &&
Gekündigt zum {fmt(c.cancelEffectiveAt)}
}
}
-

Ressourcen und Lizenzen

+ {contracts.map((c) => {c.number}{c.productName}{c.termEnd ? fmtDate(c.termEnd) : 'unbefristet'}{c.cancelEffectiveAt &&
Gekündigt zum {fmtDate(c.cancelEffectiveAt)}
})}
}
+

Hosting und Lizenzen

{ress === null ?

Wird geladen …

: ress.length === 0 ? :
- {ress.map((r) => )}
NameStatusGültig bisLizenzschlüssel
{r.name}{r.stale && <> Veraltet}{r.validUntil ? fmt(r.validUntil) : 'unbefristet'}{r.canReveal ? : –}
}
+ {ress.map((r) => {r.name}{r.stale && <> Veraltet}{r.validUntil ? fmtDate(r.validUntil) : 'unbefristet'}{r.canReveal ? : –})}} {can('domains.read') &&

Domains

} {can('invoices.read') &&
}

Bestellungen

@@ -89,7 +103,14 @@ export default function Kunde() {

Benutzer

{w && }

Enthält den Zugangslink, die aktuellen Produkte mit Preisen und eine kurze Anleitung inkl. Discord-Verknüpfung. Geht an den ersten Ansprechpartner.

- {o.members.map((m) => )}
NameE-MailRolleStatusAktionen
{m.name}{m.email}{ROLE_LABEL[m.role]}{w && m.status === 'invited' && }
+ {o.members.map((m) => editUser === m.id ? + void saveUser(e, m)}> +
+
+ {o.billing.billingEmail === m.email && } +
+ + : {m.name}{m.email}{ROLE_LABEL[m.role]}
{can('users.write') && }{w && m.status === 'invited' && }
)}
{w &&

Kundenart

{switchTo ? (

Zu {switchTo === 'private' ? 'Privatkunde' : 'Geschäftskunde'} wechseln? {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.

) diff --git a/apps/web/src/app/(app)/admin/kunden/page.tsx b/apps/web/src/app/(app)/admin/kunden/page.tsx index 2eb6eda..5a13c13 100644 --- a/apps/web/src/app/(app)/admin/kunden/page.tsx +++ b/apps/web/src/app/(app)/admin/kunden/page.tsx @@ -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([]); const [msg, setMsg] = useState<{ k: 'ok' | 'err'; t: string } | null>(null); + const load = useCallback(() => { api('GET', '/admin/registration-settings').then(setCfg).catch(() => undefined); api('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 (

Selbstregistrierung

+ {msg && {msg.t}} +

Status: {cfg.enabled ? 'eingeschaltet' : 'aus'} · Freischaltung: {cfg.approval === 'auto' ? 'automatisch nach E-Mail-Bestätigung' : 'durch das Personal'}

+ {can('settings.write') &&
+ +
} + {regs.length > 0 &&
+ {regs.map((r) => + )} +
KundeArtE-MailBestätigt
{r.orgName} ({r.customerNumber}){r.customerType === 'business' ? 'Geschäftskunde' : 'Privatkunde'}{r.email}{new Date(r.verifiedAt).toLocaleString('de-DE', { dateStyle: 'short', timeStyle: 'short' })}{can('customers.write') &&
}
} +
); +} + 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 (<>

Kunden

{can('customers.write') &&
Aus Verbindung übernehmen
}
+ {err && {err}} {created && 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): {created.inviteLink}}} {open &&

Neuer Kunde

diff --git a/apps/web/src/app/(app)/admin/posteingang/page.tsx b/apps/web/src/app/(app)/admin/posteingang/page.tsx index 0345e12..191f845 100644 --- a/apps/web/src/app/(app)/admin/posteingang/page.tsx +++ b/apps/web/src/app/(app)/admin/posteingang/page.tsx @@ -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 = { 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 (
{m.subject || '(kein Betreff)'}

Von: {m.fromName ? `${m.fromName} <${m.fromEmail}>` : m.fromEmail} · {fmt(m.receivedAt)}

+ {(m.suggestedTicketNumber || m.suggestedOrgId) &&

Vorschlag aus Betreff/Absender vorausgefüllt. Der Absender ist nicht nachgewiesen (keine Antwort auf eine Kundencenter-Mail) – bitte prüfen, bevor Sie zuordnen.

} + {m.processingError &&

Automatische Verarbeitung fehlgeschlagen: {m.processingError}

} {open &&
{m.bodyText || '(kein Text)'}
}
diff --git a/apps/web/src/app/(app)/admin/status/page.tsx b/apps/web/src/app/(app)/admin/status/page.tsx new file mode 100644 index 0000000..1a2e9aa --- /dev/null +++ b/apps/web/src/app/(app)/admin/status/page.tsx @@ -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) { + 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 ( + {e.title} ({e.kind === 'incident' ? 'Störung' : 'Wartung'}{e.component ? `, ${e.component}` : ''}, Auswirkung {e.impact}, seit {fmt(e.startsAt)}) +
    {e.updates.map((u, i) =>
  • {u.state} ({fmt(u.at)}): {u.body}
  • )}
+
+
+ + + ); +} +/** Verwaltung der öffentlichen Statusseite (#23). Nur eigene Texte, keine Kunden- oder Anbieterdetails eintragen. */ +export default function StatusAdmin() { + const { can } = useSession(); + const [list, setList] = useState(null); const [msg, setMsg] = useState<{ k: 'ok' | 'err'; t: string } | null>(null); const [kind, setKind] = useState<'incident' | 'maintenance'>('incident'); + const load = useCallback(() => api('GET', '/admin/status-events').then(setList).catch((e) => setMsg({ k: 'err', t: errMsg(e) })), []); + useEffect(() => { void load(); }, [load]); + async function create(ev: FormEvent) { + 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 (<> +

Statusseite

Öffentliche Ansicht
+

Öffentlich sichtbar ist nur, was hier veröffentlicht wird. Bitte keine Kundennamen, Ressourcen oder internen Details eintragen.

+ {msg && {msg.t}} + {w &&

Neuer Eintrag

+
{([['incident', 'Störung'], ['maintenance', 'Wartung']] as const).map(([k, l]) => )}
+
+
+ {kind === 'maintenance' &&
} + + +
} + {list === null ?

Wird geladen …

: list.length === 0 ?
: list.map((e) => { setMsg(m); void load(); }} />)} + ); +} diff --git a/apps/web/src/app/(app)/auswertung/page.tsx b/apps/web/src/app/(app)/auswertung/page.tsx new file mode 100644 index 0000000..a0ca1dc --- /dev/null +++ b/apps/web/src/app/(app)/auswertung/page.tsx @@ -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 = { 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 }) =>

{label}

{value}

{sub &&

{sub}

}
; + +/** 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(null); const [err, setErr] = useState(''); + const load = useCallback(() => { setErr(''); api('GET', `/analytics/summary?from=${from}&to=${to}`).then(setS).catch((e) => setErr(errMsg(e))); }, [from, to]); + useEffect(() => { load(); }, [load]); + return (<> +

Auswertung

+
setFrom(e.target.value)} /> setTo(e.target.value)} />
+ {err && {err}} + {!s ?

Wird geladen …

: (<> +

Datenstand {new Date(s.dataAsOf).toLocaleString('de-DE')} · Beträge in {s.currency} · {s.period.basis}

+
+ + + + + + + +
+

Nach Produktkategorie

+ {s.byCategory.map((c) => )}
KategorieNettoBrutto
{CAT[c.category] ?? c.category}{eur(c.netCents)}{eur(c.grossCents)}
+

Nach Steuersatz

+ {s.byTaxRate.map((t) => )}
USt.NettoSteuerBrutto
{t.taxBp / 100} %{eur(t.netCents)}{eur(t.taxCents)}{eur(t.grossCents)}
+

Nach Monat (netto)

+ {s.byMonth.map((m) => )}
MonatAusgestelltStornosNach Storno
{m.month}{eur(m.issuedNetCents)}{eur(m.creditNetCents)}{eur(m.netAfterCreditsCents)}
+

So wird gerechnet

    {s.definitions.map((d) =>
  • {d}
  • )}
+ )} + ); +} diff --git a/apps/web/src/app/(app)/bestellen/page.tsx b/apps/web/src/app/(app)/bestellen/page.tsx index 275ac56..84c0266 100644 --- a/apps/web/src/app/(app)/bestellen/page.tsx +++ b/apps/web/src/app/(app)/bestellen/page.tsx @@ -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) { 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() { )}
{staff && } +

{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.'}

} diff --git a/apps/web/src/app/(app)/bestellungen/page.tsx b/apps/web/src/app/(app)/bestellungen/page.tsx index 8dfc987..20da87d 100644 --- a/apps/web/src/app/(app)/bestellungen/page.tsx +++ b/apps/web/src/app/(app)/bestellungen/page.tsx @@ -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(null); const [msg, setMsg] = useState<{ k: 'ok' | 'err'; t: string } | null>(null); const [busy, setBusy] = useState(''); const [chk, setChk] = useState>({}); @@ -20,6 +20,7 @@ export default function Bestellungen() {

{o.number}{staff && · {o.orgName}}

Bestellt am {fmt(o.createdAt)}{o.note ? ` · „${o.note}“` : ''}

{o.items.map((i) =>
{i.quantity} × {i.snapshot.name}{i.contractId && <> · Vertrag}
)} + {(o.domains ?? []).map((d) =>
Domain {d.domain}
{d.termMonths} Monate: {eur(d.sellGrossCents)} inkl. USt. ({eur(d.sellNetCents)} netto){d.setupGrossCents > 0 ? `, Einrichtung ${eur(d.setupGrossCents)}` : ''}{d.recorded ? ' · in Beschaffung' : ''}
)} {o.status === 'failed' && o.failureNote && {o.failureNote}} {o.status === 'provisioning' &&

Die Bereitstellung läuft im Hintergrund. Diese Seite aktualisiert sich automatisch.

}
diff --git a/apps/web/src/app/(app)/dashboard/page.tsx b/apps/web/src/app/(app)/dashboard/page.tsx index 38cc7a7..d836ff7 100644 --- a/apps/web/src/app/(app)/dashboard/page.tsx +++ b/apps/web/src/app/(app)/dashboard/page.tsx @@ -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; 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(null); const [inv, setInv] = useState(null); + useEffect(() => { + if (tickets) api('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('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 (
+ {tickets &&

Aktuelle Tickets

Alle Tickets
+ {t === null ?

Wird geladen …

: t.length === 0 ?

Keine offenen Tickets.

+ :
    {t.map((x) =>
  • {x.subject}{x.number}{staff && ` · ${x.orgName}`} · {fmt(x.lastMessageAt)}
  • )}
} +
} + {invoices &&

Offene Rechnungen

Alle Rechnungen
+ {inv === null ?

Wird geladen …

: inv.length === 0 ?

Keine offenen Rechnungen.

+ :
    {inv.map((x) =>
  • {x.number ?? 'Entwurf'} · {eur(x.totalGrossCents)}{staff && `${x.orgName} · `}fällig {x.dueDate ? fmtDay(x.dueDate) : '–'}
  • )}
} +
} +
); +} -interface Sys { jobs: Record; 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(null); const [sys, setSys] = useState(null); const [err, setErr] = useState(''); + const [customers, setCustomers] = useState(null); const [sys, setSys] = useState(null); const [drift, setDrift] = useState([]); const [err, setErr] = useState(''); useEffect(() => { if (me?.kind === 'customer') { Promise.all([api('GET', '/contracts'), api('GET', '/resources'), api('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('GET', '/admin/customers').then((l) => setCustomers(l.length)).catch((e) => setErr(errMsg(e))); if (can('jobs.read')) api('GET', '/admin/system').then(setSys).catch((e) => setErr(errMsg(e))); + if (can('resources.read')) api('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 &&
Sobald Produkte, Verträge, Rechnungen oder Tickets für Ihre Organisation vorhanden sind, erscheinen sie hier.
} {mine && (mine.contracts.length > 0 || mine.resources.length > 0 || mine.orders.length > 0) &&
{mine.contracts.filter((c) => c.status === 'active').length}

Aktive Verträge

{mine.contracts.some((c) => c.cancelEffectiveAt) &&

Gekündigter Vertrag vorhanden

}Verträge ansehen
-
{mine.resources.length}

Ressourcen und Lizenzen

{mine.resources.some((r) => r.stale) &&

Stand teilweise veraltet

}Ressourcen ansehen
+
{mine.resources.length}

Hosting und Lizenzen

{(() => { const lic = mine.resources.filter((r) => r.type === 'license').length; const host = mine.resources.length - lic; return mine.resources.length > 0 &&

{[host > 0 && `${host} Webhosting`, lic > 0 && `${lic} ${lic === 1 ? 'Lizenz' : 'Lizenzen'}`].filter(Boolean).join(' · ')}

; })()}{mine.resources.some((r) => r.stale) &&

Stand teilweise veraltet

}Alle ansehen
{mine.orders.filter((o) => ['pending_approval', 'provisioning', 'failed'].includes(o.status)).length > 0 &&
{mine.orders.filter((o) => ['pending_approval', 'provisioning', 'failed'].includes(o.status)).length}

Bestellungen in Bearbeitung

Bestellungen ansehen
}
} ) : (<> @@ -41,6 +66,11 @@ export default function Dashboard() { {customers !== null &&
{customers}

Kunden

Kunden verwalten
} {licenses &&
{licenses.active}

Aktive Lizenzen

{licenses.expiring > 0 &&

{licenses.expiring} laufen in 30 Tagen ab

}{licenses.unassigned > 0 &&

{licenses.unassigned} ohne Kunde

}Lizenzen verwalten
} {sys &&
{sys.jobs.scheduled ?? 0}

Wartende Aufträge

} + {drift.length > 0 &&

Abweichungen Vertrag ↔ Anbieter

+

Nur Anzeige – es wird nichts automatisch zurückgeschrieben.

+
    {drift.map((d) =>
  • {d.kind === 'mismatch' ? 'Abweichung' : 'ungewiss'} {d.resourceName} ({d.orgName}, {d.contractNumber}): {d.reason}
  • )}
} + {sys?.alerts && sys.alerts.length > 0 &&

Betriebsalarme

+
    {sys.alerts.map((a) =>
  • {a.label}{a.detail ? ` – ${a.detail}` : ''} (seit {new Date(a.since).toLocaleString('de-DE', { dateStyle: 'short', timeStyle: 'short' })})
  • )}
} {sys?.backup &&

Backup

Details und Einstellungen

{!sys.backup.configured ? <>

Nicht eingerichtet.

Kein Backup : <>

{sys.backup.stale ? {sys.backup.ok ? 'Veraltet' : 'Fehlgeschlagen'} : Aktuell}

@@ -49,5 +79,6 @@ export default function Dashboard() { {sys &&
{failed}

Aufträge mit Fehlern / Prüfbedarf

{failed > 0 && Prüfen}
}
)} + ); } diff --git a/apps/web/src/app/(app)/einstellungen/firma/page.tsx b/apps/web/src/app/(app)/einstellungen/firma/page.tsx index 47e5def..1b63520 100644 --- a/apps/web/src/app/(app)/einstellungen/firma/page.tsx +++ b/apps/web/src/app/(app)/einstellungen/firma/page.tsx @@ -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() {
+

DATEV-Export

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).

{!s.datev.complete && DATEV-Stammdaten unvollständig: Beraternummer und Mandantennummer fehlen noch.} diff --git a/apps/web/src/app/(app)/einstellungen/verbindungen/page.tsx b/apps/web/src/app/(app)/einstellungen/verbindungen/page.tsx index 86c0b59..2dff023 100644 --- a/apps/web/src/app/(app)/einstellungen/verbindungen/page.tsx +++ b/apps/web/src/app/(app)/einstellungen/verbindungen/page.tsx @@ -31,6 +31,7 @@ export default function Connectors() { {msg && {msg.t}} {open && type &&

Neue Verbindung

{sel === 'keyhelp' && KeyHelp einrichten: Im KeyHelp-Adminbereich unter Konfiguration → API die API aktivieren und einen Schlüssel anlegen. Den Schlüssel auf die IP-Adresse dieses Servers beschränken (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.} + {sel === 'plesk' && Plesk einrichten: Auf dem Plesk-Server als root einen Secret Key erzeugen: plesk bin secret_key -c -ip-address <IP dieses Servers> -description Kundencenter. Der Schlüssel ist an diese IP gebunden und hat Administratorrechte. Adresse mit Port angeben (meist :8443); 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.}
diff --git a/apps/web/src/app/(app)/layout.tsx b/apps/web/src/app/(app)/layout.tsx index 8e3d445..a0c2065 100644 --- a/apps/web/src/app/(app)/layout.tsx +++ b/apps/web/src/app/(app)/layout.tsx @@ -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 = { + '/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

Wird geladen …

; - const link = (href: string, label: string) => {label}; + const link = (href: string, label: string) => {ICONS[href] && }{label}; const inGroup = (hrefs: string[]) => hrefs.some((h) => path === h || path.startsWith(h + '/')); const group = (title: string, hrefs: string[], items: ReactNode) => ( -
{title}
{items}
+
{title}
{items}
); 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 = ( ); - const bottomLink = (href: string, label: string) => {label}; + const bottomLink = (href: string, label: string, icon: IconName) => {label}; return (<> {me.impersonating && ( -
- 👁 Ansicht als Kunde: {me.impersonating.orgName} ({me.impersonating.customerNumber}) · Grund: {me.impersonating.reason} +
+ Ansicht als Kunde: {me.impersonating.orgName} ({me.impersonating.customerNumber}) · Grund: {me.impersonating.reason}
)}
-
Kundencenter
- {nav}
{trial && path !== '/einstellungen/lizenz' &&
{trial} Lizenz hinterlegen
}{children}
+
+ {nav}
{trial && path !== '/einstellungen/lizenz' &&
{trial} Lizenz hinterlegen
}{children}
{!enrollNeeded && }
); diff --git a/apps/web/src/app/(app)/lizenzen/[id]/page.tsx b/apps/web/src/app/(app)/lizenzen/[id]/page.tsx index 6202aed..903fb39 100644 --- a/apps/web/src/app/(app)/lizenzen/[id]/page.tsx +++ b/apps/web/src/app/(app)/lizenzen/[id]/page.tsx @@ -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) { 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() {
{d.program ?? '–'}
{d.product ?? d.edition ?? '–'}
{d.durationType ? DURATION[d.durationType] ?? d.durationType : '–'}
-
{d.validFrom ? fmt(d.validFrom) : '–'}
-
{d.validUntil ? fmt(d.validUntil) : 'unbefristet'}
+
{d.validFrom ? fmtDate(d.validFrom) : '–'}
+
{d.validUntil ? fmtDate(d.validUntil) : 'unbefristet'}
{d.lastCheckAt ? fmt(d.lastCheckAt) : 'noch nie'}
{d.contractId ? Vertrag {d.contractNumber} : 'ohne Berechnung'}
{d.parent &&
{d.parent.program}{d.parent.product ? ` · ${d.parent.product}` : ''}
} @@ -166,7 +166,7 @@ export default function Lizenz() { } {(!d.addon && (d.addons.length > 0 || d.can.manage)) &&

Add-ons

{d.can.manage && d.orgId && Add-on vergeben}
- {d.addons.length === 0 ?

Keine Add-ons.

:
    {d.addons.map((x) =>
  • {x.product ?? x.name} bis {x.validUntil ? fmt(x.validUntil) : 'unbefristet'}
  • )}
} + {d.addons.length === 0 ?

Keine Add-ons.

:
    {d.addons.map((x) =>
  • {x.product ?? x.name} bis {x.validUntil ? fmtDate(x.validUntil) : 'unbefristet'}
  • )}
}
} {staff && d.history.length > 0 &&

Verlauf

diff --git a/apps/web/src/app/(app)/lizenzen/page.tsx b/apps/web/src/app/(app)/lizenzen/page.tsx index 1657b73..4d56375 100644 --- a/apps/web/src/app/(app)/lizenzen/page.tsx +++ b/apps/web/src/app/(app)/lizenzen/page.tsx @@ -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() { - + )}
ZeitpunktVorgangDurchErgebnis
{l.program ?? l.name}{l.product ? ` · ${l.product}` : ''}
{l.keyMasked}
{l.orgId ? {l.customerNumber} · {l.orgName} : Nicht zugewiesen} {l.validUntil ? <>{fmt(l.validUntil)}{soon(l.validUntil) && l.state === 'active' && <> bald} : 'unbefristet'}{l.validUntil ? <>{fmtDate(l.validUntil)}{soon(l.validUntil) && l.state === 'active' && <> bald} : 'unbefristet'} {devices(l)} {l.contractId ? {l.contractNumber} : ohne Berechnung}
@@ -58,7 +58,7 @@ export default function Lizenzen() {

{l.program ?? l.name}

{l.product ?? l.edition}
-
Gültig bis: {l.validUntil ? fmt(l.validUntil) : 'unbefristet'}
+
Gültig bis: {l.validUntil ? fmtDate(l.validUntil) : 'unbefristet'}
Geräte: {devices(l)}
Details und Geräte
diff --git a/apps/web/src/app/(app)/rechnungen/[id]/page.tsx b/apps/web/src/app/(app)/rechnungen/[id]/page.tsx index 315ffc3..4af2821 100644 --- a/apps/web/src/app/(app)/rechnungen/[id]/page.tsx +++ b/apps/web/src/app/(app)/rechnungen/[id]/page.tsx @@ -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 (<>

{inv.number ?? 'Entwurf'} {inv.orgName && · {inv.orgName}}

← Rechnungen
-

{inv.issueDate && <> · ausgestellt {fmt(inv.issueDate)}}{inv.dueDate && <> · fällig {fmt(inv.dueDate)}}{inv.paymentMethod && <> · {inv.paymentMethod}}

+

{inv.issueDate && <> · ausgestellt {fmtDay(inv.issueDate)}}{inv.dueDate && <> · fällig {fmtDay(inv.dueDate)}}{inv.paymentMethod && <> · {inv.paymentMethod}}

{inv.cancelsInvoiceId && Dies ist eine Stornorechnung zu einer anderen Rechnung.} {inv.cancelledByInvoiceId && Diese Rechnung wurde storniert. Storno: ansehen} {err && {err}}{ok && {ok}} @@ -95,6 +95,7 @@ export default function RechnungDetail() { {!isDraft &&
PDF ansehen {inv.canWrite && inv.status === 'open' && } + {inv.canWrite && inv.status === 'cancelled' && (inv.billingPeriods?.length ?? 0) > 0 && } {inv.canWrite && inv.status === 'open' && }
} {inv.note &&

Notiz: {inv.note}

} diff --git a/apps/web/src/app/(app)/rechnungen/faellig/page.tsx b/apps/web/src/app/(app)/rechnungen/faellig/page.tsx index 3e30d3f..a0bb307 100644 --- a/apps/web/src/app/(app)/rechnungen/faellig/page.tsx +++ b/apps/web/src/app/(app)/rechnungen/faellig/page.tsx @@ -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 (
+

Abrechnungslauf

+

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).

+ {msg && {msg.t}} + {p === null ?

Wird geladen …

: p.periods.length === 0 ? : +
+ {p.periods.map((x) => ())} +
VertragZeitraumPositionNetto
{x.contractNumber}{fmtDay(x.start)} – {fmtDay(x.end)}{x.description}{eur(x.unitPriceNetCents)}
} +
); +} export default function Faellig() { const r = useRouter(); const [d, setD] = useState(null); const [err, setErr] = useState(''); const [busy, setBusy] = useState(''); - useEffect(() => { api('GET', '/invoices/reminders').then(setD).catch((e) => setErr(errMsg(e))); }, []); + const reload = () => api('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() {

Fällig

← Rechnungen

Überfällige, bereits ausgestellte Rechnungen und aktive Verträge, bei denen die letzte Rechnung länger zurückliegt als ihre Verlängerungslaufzeit.

{err && {err}} + void reload()} /> {d === null ?

Wird geladen …

: (<>

Überfällige Rechnungen ({d.overdueInvoices.length})

{d.overdueInvoices.length === 0 ? :
{d.overdueInvoices.map((i) => ( - ))} + ))}
Nr.KundeFällig seitBetrag
{i.number}{i.orgName} ({i.customerNumber}){i.dueDate ? fmt(i.dueDate) : '–'}{eur(i.totalGrossCents)}
{i.dueDate ? fmtDay(i.dueDate) : '–'}{eur(i.totalGrossCents)}
}
diff --git a/apps/web/src/app/(app)/ressourcen/[id]/page.tsx b/apps/web/src/app/(app)/ressourcen/[id]/page.tsx index de31e86..cdf161b 100644 --- a/apps/web/src/app/(app)/ressourcen/[id]/page.tsx +++ b/apps/web/src/app/(app)/ressourcen/[id]/page.tsx @@ -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 && Diese Ressource wurde beim letzten Abgleich nicht mehr beim Anbieter gefunden.}

Details

-
Gültig ab
{d.validFrom ? fmt(d.validFrom) : '–'}
-
Gültig bis
{d.validUntil ? fmt(d.validUntil) : 'unbefristet'}
+
Gültig ab
{d.validFrom ? fmtDate(d.validFrom) : '–'}
+
Gültig bis
{d.validUntil ? fmtDate(d.validUntil) : 'unbefristet'}
{d.type !== 'hosting_account' && Object.entries(d.limits).map(([k, v]) =>
{LIMIT_LABEL[k] ?? k}
{v === null ? 'unbegrenzt' : String(v)}{d.usage[k] !== undefined ? ` (genutzt: ${String(d.usage[k])})` : ''}
)} {d.details.edition &&
Edition
{String(d.details.edition)}
} {d.details.program &&
Programm
{String(d.details.program)}
} diff --git a/apps/web/src/app/(app)/ressourcen/page.tsx b/apps/web/src/app/(app)/ressourcen/page.tsx index 7c4d58a..8537e8e 100644 --- a/apps/web/src/app/(app)/ressourcen/page.tsx +++ b/apps/web/src/app/(app)/ressourcen/page.tsx @@ -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 ? (
{!lic && }{lic && } {rows.map((r) => {!lic && } - {lic && })}
NameTypStatusGültig bisStandLizenzschlüssel
{r.name}{!r.orgId && <> Nicht zugewiesen}{canAssign && !r.orgId &&
{ 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(); }} />
}
{TYPE[r.type] ?? r.type}{r.validUntil ? fmt(r.validUntil) : 'unbefristet'}{fmt(r.syncedAt)}{r.stale && <> Veraltet}{r.canReveal ? : –}
+ {r.validUntil ? fmtDate(r.validUntil) : 'unbefristet'}{fmt(r.syncedAt)}{r.stale && <> Veraltet}{lic && {r.canReveal ? : –}})}
) : (
{rows.map((r) => (

{r.name}

{!lic &&
{TYPE[r.type] ?? r.type}
} -
Gültig bis: {r.validUntil ? fmt(r.validUntil) : 'unbefristet'}
+
Gültig bis: {r.validUntil ? fmtDate(r.validUntil) : 'unbefristet'}
Stand: {fmt(r.syncedAt)}{r.stale && <> Veraltet}
{lic && r.canReveal &&
}
Details ansehen
diff --git a/apps/web/src/app/(app)/tickets/[id]/page.tsx b/apps/web/src/app/(app)/tickets/[id]/page.tsx index 7bae736..2a4310d 100644 --- a/apps/web/src/app/(app)/tickets/[id]/page.tsx +++ b/apps/web/src/app/(app)/tickets/[id]/page.tsx @@ -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 (
{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.filename} - : 📄 {a.filename} ({kb} KB); })} + ? {a.filename} + : {a.filename} ({kb} KB); })}
); } interface Msg { id: string; authorId: string; authorName: string; authorKind: 'customer' | 'staff'; body: string; internalNote: boolean; createdAt: string; attachments: Attachment[] } diff --git a/apps/web/src/app/(app)/vertraege/[id]/page.tsx b/apps/web/src/app/(app)/vertraege/[id]/page.tsx index c0ef64c..6dcc4ef 100644 --- a/apps/web/src/app/(app)/vertraege/[id]/page.tsx +++ b/apps/web/src/app/(app)/vertraege/[id]/page.tsx @@ -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('GET', `/contracts/${id}`).then(setD).catch((e) => setMsg({ k: 'err', t: errMsg(e) })), [id]); useEffect(() => { void load(); }, [load]); if (!d) return msg ? {msg.t} :

Wird geladen …

; - 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) { e.preventDefault(); const f = new FormData(e.currentTarget); const g = (k: string) => String(f.get(k) ?? ''); @@ -34,12 +34,12 @@ export default function Vertrag() {

← Alle Verträge

{d.productName}

{d.number} · {d.orgName}

{msg && {msg.t}} - {pending && Dieser Vertrag ist gekündigt und endet am {fmt(d.cancelEffectiveAt!)}.} + {pending && Dieser Vertrag ist gekündigt und endet am {fmtDate(d.cancelEffectiveAt!)}.}

Konditionen

Preis
Beginn
{d.startedAt ? fmt(d.startedAt) : '–'}
-
Laufzeit bis
{d.termEnd ? fmt(d.termEnd) : 'unbefristet'}
+
Laufzeit bis
{d.termEnd ? fmtDate(d.termEnd) : 'unbefristet'}
Verlängerung
{d.renewal === 'auto' ? `automatisch um ${d.renewalTermMonths} Monat(e)` : 'keine'}
Kündigungsfrist
{d.noticeDays} Tage
Abrechnung
{INTERVAL[d.price.interval]}
diff --git a/apps/web/src/app/(app)/vertraege/page.tsx b/apps/web/src/app/(app)/vertraege/page.tsx index 0f502e0..c37dc8e 100644 --- a/apps/web/src/app/(app)/vertraege/page.tsx +++ b/apps/web/src/app/(app)/vertraege/page.tsx @@ -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 ?

Wird geladen …

: list.length === 0 ? Verträge entstehen aus Bestellungen. :
{staff && } {list.map((c) => {staff && } - )}
Nr.ProduktKundePreisLaufzeit bisStatus
{c.number}{c.productName}{c.orgName}{c.termEnd ? fmt(c.termEnd) : 'unbefristet'}{c.cancelEffectiveAt &&
Gekündigt zum {fmt(c.cancelEffectiveAt)}
}
} + {c.termEnd ? fmtDate(c.termEnd) : 'unbefristet'}{c.cancelEffectiveAt &&
Gekündigt zum {fmtDate(c.cancelEffectiveAt)}
})}
}
); } diff --git a/apps/web/src/app/apple-icon.png b/apps/web/src/app/apple-icon.png new file mode 100644 index 0000000..8126d3f Binary files /dev/null and b/apps/web/src/app/apple-icon.png differ diff --git a/apps/web/src/app/email-bestaetigen/page.tsx b/apps/web/src/app/email-bestaetigen/page.tsx new file mode 100644 index 0000000..b365782 --- /dev/null +++ b/apps/web/src/app/email-bestaetigen/page.tsx @@ -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 ? {state.t} :

Wird bestätigt …

}; +} +export default function EmailBestaetigen() { + return

E-Mail bestätigen

+ Wird geladen …

}>
+

Zur Anmeldung

; +} diff --git a/apps/web/src/app/favicon.ico b/apps/web/src/app/favicon.ico new file mode 100644 index 0000000..6a35c21 Binary files /dev/null and b/apps/web/src/app/favicon.ico differ diff --git a/apps/web/src/app/globals.css b/apps/web/src/app/globals.css index 6b5e02a..7db5098 100644 --- a/apps/web/src/app/globals.css +++ b/apps/web/src/app/globals.css @@ -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; } } diff --git a/apps/web/src/app/icon.png b/apps/web/src/app/icon.png new file mode 100644 index 0000000..0448235 Binary files /dev/null and b/apps/web/src/app/icon.png differ diff --git a/apps/web/src/app/layout.tsx b/apps/web/src/app/layout.tsx index 7cf7f1d..c2333e8 100644 --- a/apps/web/src/app/layout.tsx +++ b/apps/web/src/app/layout.tsx @@ -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