Onboarding Dashboard

title	Onboarding Dashboard
emoji	📊
colorFrom	red
colorTo	indigo
sdk	docker
app_port	7860
pinned	false

Onboarding Dashboard

Interne Onboarding- und Vertriebs-Steuerungsplattform für Swiss Life Select Austria (SLS AT) — eine webbasierte Anwendung zur Verwaltung von Lernreisen, wöchentlichem Vertriebs-Tracking und Team-Führung mit rollenbasiertem Zugriff.

Überblick

Das Onboarding Dashboard ist eine spezialisierte Plattform für die interne Nutzung bei Swiss Life Select Austria. Sie unterstützt drei Säulen:

Säule 1: Lernreise (Onboarding)

Strukturierte, sequenziell freigeschaltete Lerninhalte für neue Berater:innen. Hierarchie: Phase → Level → Kategorie → Content-Item. Unterstützt Videos (mit Mindest-Ansichtszeit und Quiz-Gating), Texte, PDFs (Inline-Viewer), Formulare, Links und Hinweise. Jedes Level hat Lernziele mit Bestätigung und To-do-Listen. Level schalten automatisch frei, wenn alle Items des Vorgänger-Levels abgeschlossen sind — oder manuell durch die Führungskraft.

Säule 2: Vertriebssteuerung und Recruiting

Jahresplanung mit Ziel-Einkommen, Quoten und bearbeitbaren Monatsgewichtungen. Wöchentliches Tracking für Kontakte, Gespräche, Abschlusstypen (AT/BT/ST). Ähnlich für Recruiting (Bewerbergespräche, Termine, Praktika). Teamleiter und Admin erhalten Übersichtsdashboards mit Ist-Erfüllung und Fortschritt.

Säule 3: Team-Führung

Teamleiter und Admin begleiten die Starter-Entwicklung: Starterführung mit individueller Level-Freischaltung, Zielzuweisung mit Teilaufgaben, wöchentliche Meetings/Journal, Ankündigungen, interne Nachrichten (threadbar). Audit-Logging aller Änderungen.

Wichtig: Das ursprüngliche Lead-/CRM-Subsystem wurde aus dem Code entfernt. Diese Dokumentation beschreibt den aktuellen Stand.

Dokumentation

Dokument	Beschreibung
docs/README.md	🗂️ Dokumentations-Index — zentrale Übersicht aller Dokumentation
docs/ARCHITECTURE.md	📐 Detaillierte Architektur: Datenmodelle, API-Konzepte, Sicherheit
docs/CODEMAP.md	🤖 Auto-generierte Dateistruktur und Modulübersicht (via PostToolUse-Hook aktualisiert)
docs/DATA_MODEL.md	🤖 Auto-generierte ORM-Modell-Referenz (via PostToolUse-Hook aktualisiert)
docs/API.md	🤖 Auto-generierte REST-API-Referenz mit Endpoints und Beispielen (via PostToolUse-Hook aktualisiert)
docs/ROUTES.md	🤖 Auto-generierte Router-Übersicht — welche Module welche Endpoints bereitstellen (via PostToolUse-Hook aktualisiert)
docs/integration/SLS-IT-INTEGRATION.md	🔌 IT-Integrationsleitfaden — MS-Entra-Anbindung, Token-Kontrakt, Rollen-Matching, Rollout, Troubleshooting
Spec.md	📋 Quelle der Wahrheit — fachliche Spezifikation, KPI-Definitionen, Rollen, Status-Übergänge, Zielarchitektur (Kapitel 9)
CLAUDE.md	👨‍💻 Entwickler-Dokumentation für KI-Assistenten und Onboarding

Die auto-generierten Dateien (CODEMAP, DATA_MODEL, API, ROUTES — gekennzeichnet mit 🤖) werden automatisch bei jedem Deployment aktualisiert. Sie sind Referenzen, keine Quellen; Änderungen müssen im Code gemacht werden.

Architektur

┌─────────────────────────┐      ┌─────────────────────────┐      ┌─────────────────────┐
│      Frontend           │      │       Backend            │      │    Datenbank        │
│                         │      │                         │      │                     │
│  React 18 + TypeScript  │─────▶│  FastAPI (async)         │─────▶│  SQLite (Dev)       │
│  Vite + Tailwind        │ API  │  SQLAlchemy 2.0          │      │  PostgreSQL (Prod)  │
│                         │      │  16 Router-Module        │      │                     │
│  Dev: Port 5173         │      │  Dev: Port 8000          │      │  Port 5432          │
│  Prod: nginx 80/443     │      │  Prod: Port 8000 (intern)│      │  (intern)           │
└─────────────────────────┘      └─────────────────────────┘      └─────────────────────┘

Komponenten

Komponente	Technologie	Dev-Port	Prod-Port	Beschreibung
Frontend	React 18, TypeScript, Vite, Tailwind CSS	5173	80/443	Rollenbasierte Dashboards (Starter/Teamleiter/Admin) mit 21 Seiten
Backend	FastAPI, SQLAlchemy 2.0 (async), Alembic	8000	8000 (intern)	16 Router-Module, ~47 Endpoints in `onboarding.py` allein, Session-Auth (CSRF-Protected)
Datenbank	SQLite (Dev) / PostgreSQL 16 (Prod)	—	5432 (intern)	12 ORM-Modelle: User, Team, Onboarding, Tracking, Recruiting, Goals, Meetings, etc.
Reverse Proxy	Vite Proxy (Dev) / nginx (Prod)	—	80/443	API-Weiterleitung mit SSL-Terminierung

Proxy-Verhalten

Entwicklung: Vite leitet alle /api/*-Anfragen an http://localhost:8000 weiter und entfernt das /api-Präfix. Frontend sendet POST /api/auth/login → Backend empfängt POST /auth/login.

Produktion: nginx leitet /api/* an den Backend-Container (http://backend:8000) weiter (ebenfalls mit Präfix-Entfernung). Frontend wird als statische Dateien von nginx ausgeliefert.

Voraussetzungen

Für Docker-Deployment (empfohlen)

Software	Mindestversion	Prüfbefehl
Docker	≥ 24.0	`docker --version`
Docker Compose	≥ 2.x (im Docker-CLI integriert)	`docker compose version`

Für manuelle/Entwicklungs-Installation

Software	Mindestversion	Prüfbefehl
Python	3.12+	`python3 --version`
Node.js	20+	`node --version`
npm	(mitgeliefert mit Node.js)	`npm --version`
Git	—	`git --version`

Schnellstart (Entwicklung)

Mit scripts/dev.sh (automatisiert, empfohlen)

# Repository klonen
git clone https://github.com/moeffel/onboarding-dashboard.git
cd onboarding-dashboard

# Backend + Frontend starten (Auto-Setup, Hot-Reload)
./scripts/dev.sh

# Oder: Datenbank zurücksetzen und neu beseedeln
./scripts/dev.sh --reset-db

Das Skript führt automatisch aus:

Erstellt Python-Virtual-Environment in backend/venv/
Installiert Backend-Abhängigkeiten
Prüft und initialisiert die Datenbank (mit Seed-Daten)
Startet Backend auf Port 8000 (mit Hot-Reload)
Startet Frontend auf Port 5173 (Vite Dev-Server)

Zugang: http://localhost:5173 | Admin: admin@onboarding.de / admin123

Manuelle Einzelschritte

# Backend
cd backend
python3 -m venv venv
source venv/bin/activate                # Linux/macOS
# oder: venv\Scripts\activate           # Windows
pip install -r requirements.txt
alembic upgrade head                    # Migrationen anwenden
python scripts/seed_data.py             # Testdaten laden
uvicorn main:app --reload --port 8000

# Frontend (in zweitem Terminal)
cd frontend
npm install
npm run dev

Docker-Deployment

Entwicklung (docker-compose.yml)

# Starten
docker compose up

# Mit Datenbank-Reset
docker compose down -v  # Löscht Volumes
docker compose up

# Stoppen
docker compose down

Nutzt SQLite mit benanntem Volume backend-data zur Persistierung. Backend läuft auf Port 8000, Frontend auf Port 5173.

Produktion (docker-compose.prod.yml)

# Vorbereitung
git clone https://github.com/moeffel/onboarding-dashboard.git
cd onboarding-dashboard

# .env mit Secrets konfigurieren
cp .env.prod.example .env
# Editor öffnen und SECRET_KEY, DB_PASSWORD, CORS_ORIGINS setzen

# SSL-Zertifikate bereitstellen
mkdir -p ssl
# fullchain.pem und privkey.pem ablegen (siehe SSL-Konfiguration)

# Starten
docker compose -f docker-compose.prod.yml up -d

# Status prüfen
docker compose -f docker-compose.prod.yml ps
# Alle Container sollten "Up (healthy)" zeigen

# Logs ansehen
docker compose -f docker-compose.prod.yml logs -f backend
docker compose -f docker-compose.prod.yml logs -f frontend

Startet vier Services:

Service	Image	Port	Beschreibung
`db`	postgres:16-alpine	5432 (intern)	PostgreSQL mit Health-Check
`backend`	Build aus `./backend/Dockerfile`	8000 (intern)	FastAPI/uvicorn
`frontend`	Build aus `./frontend/Dockerfile`	80/443 (public)	nginx mit SSL-Terminierung
`watchtower`	containrrr/watchtower	— (intern)	Optional: automatische Updates (täglich)

nginx leitet HTTP (80) auf HTTPS (301) um. API-Anfragen unter /api/ werden an Backend weitergeleitet.

Single-Container (Hugging Face Spaces)

Das Root-Dockerfile baut einen einzelnen Container, der Frontend und Backend auf Port 7860 ausliefert:

docker build -t onboarding-dashboard .
docker run -p 7860:7860 onboarding-dashboard

Build-Prozess: Node 20 (Frontend-Build) → Python 3.12 (Backend + Frontend-Dist) → uvicorn auf Port 7860.

Umgebungsvariablen

Alle Variablen werden in backend/config.py über Pydantic Settings definiert. Die .env-Datei muss im Projekthauptverzeichnis liegen.

Variable	Pflicht	Default	Beschreibung
`SECRET_KEY`	Ja (Prod)	`change-me-...`	Signierungsschlüssel für Session-Cookies. Generieren: `python3 -c "import secrets; print(secrets.token_hex(32))"`
`DATABASE_URL`	Nein	`sqlite+aiosqlite:///./onboarding.db`	DB-Verbindungs-URL. Format: `postgresql+asyncpg://benutzer:passwort@host:5432/dbname`
`DB_POOL_SIZE`	Nein	`5`	PostgreSQL Connection-Pool-Größe
`DB_MAX_OVERFLOW`	Nein	`10`	Zusätzliche Connections bei Spitzenlast
`DB_POOL_TIMEOUT`	Nein	`30`	Timeout für Pool-Verbindungsanfragen (Sekunden)
`SESSION_COOKIE_NAME`	Nein	`session`	Name des Session-Cookies
`SESSION_MAX_AGE`	Nein	`28800`	Session-Gültigkeit in Sekunden (Standard: 8h)
`BCRYPT_ROUNDS`	Nein	`12`	Bcrypt-Hashing-Runden für Passwörter
`RATE_LIMIT_LOGIN`	Nein	`5/minute`	Login-Rate-Limit (slowapi-Format)
`RATE_LIMIT_DEFAULT`	Nein	`60/minute`	Allgemeines Rate-Limit für übrige Endpoints (slowapi-Format)
`CSRF_TOKEN_EXPIRY`	Nein	`28800`	CSRF-Token-Gültigkeit (sollte SESSION_MAX_AGE entsprechen)
`CORS_ORIGINS`	Nein	`["http://localhost:5173"]`	Erlaubte Origins (JSON-Array)
`DATA_RETENTION_DAYS`	Nein	`730`	Audit-Log-Aufbewahrung in Tagen (DSGVO: 2 Jahre)
`DEBUG`	Nein	`false`	Debug-Modus (SQL-Logging, Unsecure Cookies) — nicht in Prod
`APP_NAME`	Nein	`Onboarding Dashboard`	App-Name in OpenAPI-Docs
`UPLOADS_DIR`	Nein	automatisch	Verzeichnis für hochgeladene Dateien (Onboarding-Assets)
`STORAGE_BACKEND`	Nein	`local`	`local` (Disk, via `/uploads`) oder `supabase` (Bucket)
`SUPABASE_URL`	Nein	—	Supabase-Projekt-URL (nur bei `STORAGE_BACKEND=supabase`)
`SUPABASE_SERVICE_KEY`	Nein	—	Supabase Service-Role-Key — server-seitiges Secret (nur bei `supabase`)
`SUPABASE_BUCKET`	Nein	`uploads`	Supabase-Storage-Bucket-Name (nur bei `supabase`)
`AUTH_PROVIDER`	Nein	`session`	`session` (lokale Passwort-Sessions) oder `oidc` (MS Entra ID) — siehe Integrationsleitfaden. Browser-SSO funktioniert bereits mit `session` + den `OIDC_*`-Variablen; `oidc` aktiviert zusaetzlich den Bearer-API-Modus
`OIDC_ISSUER`	Bei `oidc`	—	Erwarteter `iss`-Claim, z.B. `https://login.microsoftonline.com/<tenant-id>/v2.0`
`OIDC_CLIENT_ID`	Bei `oidc`	—	Entra-App-Registrierungs-ID (Client-ID); zugleich Default-Audience
`OIDC_JWKS_URI`	Bei `oidc`	—	JWKS-Endpoint für die RS256-Signaturprüfung
`OIDC_AUDIENCE`	Nein	Client-ID	Überschreibt die erwartete Token-Audience
`OIDC_CLIENT_SECRET`	Bei Browser-SSO	—	Client-Secret der Entra-App (Code→Token-Tausch, nur serverseitig)
`OIDC_REDIRECT_URI`	Bei Browser-SSO	—	`https://<host>/api/auth/oidc/callback` — exakt in Entra hinterlegen
`SCIM_BEARER_TOKEN`	Nein (optional)	—	Bearer-Token für `/scim/v2/*`-Provisioning-Endpoints (SCIM 2.0 von Entra). Leer = Feature deaktiviert (404 auf alle SCIM-Anfragen). Empfohlen: `openssl rand -base64 32` (≥32 Zeichen Zufall). Siehe Integrationsleitfaden → Abschnitt 9.

Hinweis: DB_USER und DB_PASSWORD sind keine config.py-Variablen. Sie werden von docker-compose.prod.yml gelesen, um daraus die POSTGRES_*-Zugangsdaten des db-Service und die DATABASE_URL des Backends zusammenzusetzen. Generieren z.B. mit openssl rand -base64 32.

Beispiel .env.prod:

SECRET_KEY=a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6q7r8s9t0u1v2w3x4y5z6a7b8c9d0
DB_PASSWORD=xK7mQw3nZpF9bH4tD8vJ1sY2wL5cR0aM3eX6nB9jO7u4kP2z+W3vC8iY5hF1g
CORS_ORIGINS=["https://dashboard.example.at"]
DEBUG=false

Datenbank-Setup und Migrationen

SQLite (Entwicklung)

# Keine manuelle Einrichtung nötig — wird automatisch erstellt
./scripts/dev.sh
# Datei liegt unter: backend/onboarding.db

⚠️ SQLite ist nicht für Produktion geeignet — keine gleichzeitigen Schreibzugriffe, keine Benutzerverwaltung.

PostgreSQL (Produktion)

Option A: Docker-Container (empfohlen)

Wird automatisch durch docker-compose.prod.yml verwaltet — keine manuelle Einrichtung nötig.

Option B: Bestehender PostgreSQL-Server

-- Als Superuser ausführen:
CREATE USER onboarding WITH PASSWORD 'ihr-sicheres-passwort';
CREATE DATABASE onboarding OWNER onboarding;

Dann in .env:

DATABASE_URL=postgresql+asyncpg://onboarding:ihr-sicheres-passwort@db-hostname:5432/onboarding

Migrationen

# Migrationen werden beim App-Start AUTOMATISCH ausgeführt.
# Für manuelle Ausführung:
cd backend
source venv/bin/activate
alembic upgrade head              # Alle pending migrations anwenden
alembic revision --autogenerate -m "Beschreibung"  # Neue Migration erstellen
alembic downgrade -1              # Letzte Migration rückgängig machen

Alembic ist das Datenbank-Versionierungs-Tool. Migrationen liegen unter backend/alembic/versions/.

Initiale Testdaten

cd backend
source venv/bin/activate
python scripts/seed_data.py

Lädt Standard-Testkonten, Teams und Onboarding-Inhalte. Nicht in Produktion mit echten Daten ausführen — kann bestehende Daten überschreiben.

SSL-Konfiguration

ssl/
├── fullchain.pem    # TLS-Zertifikat (Server + Intermediates)
└── privkey.pem      # Privater Schlüssel

Diese Dateien werden von docker-compose.prod.yml als Read-Only-Volume in den nginx-Container gemountet.

Selbstsigniertes Zertifikat für Tests

mkdir -p ssl
openssl req -x509 -newkey rsa:4096 \
  -keyout ssl/privkey.pem \
  -out ssl/fullchain.pem \
  -days 365 -nodes \
  -subj "/CN=localhost"

Zertifikat für Produktion

Verwenden Sie ein von einer Zertifizierungsstelle (CA) signiertes Zertifikat, z.B. Let's Encrypt:

# Mit Certbot (Let's Encrypt)
certbot certonly --standalone -d dashboard.example.at
# Kopiert dann automatisch zu: /etc/letsencrypt/live/dashboard.example.at/

# Dateien nach ssl/ kopieren:
cp /etc/letsencrypt/live/dashboard.example.at/fullchain.pem ssl/
cp /etc/letsencrypt/live/dashboard.example.at/privkey.pem ssl/

Hinweis: Die Dateinamen müssen exakt fullchain.pem und privkey.pem lauten — frontend/nginx.conf referenziert diese Namen fest.

Projektstruktur

onboarding-dashboard/
├── backend/                          # Python FastAPI
│   ├── alembic/                      # Datenbank-Migrationen
│   │   └── versions/                 # Versionsierte Migrations-Dateien
│   ├── models/                       # SQLAlchemy ORM (12 Modelle)
│   │   ├── user.py                   # Benutzer, Rollen (STARTER/TEAMLEITER/ADMIN), Status
│   │   ├── onboarding.py             # Lernreise: Phase, Level, Category, Item, Goals, Todos
│   │   ├── sales_tracking.py         # Vertriebsplanung & Tracking
│   │   ├── recruiting.py             # Recruiting-Plan & Tracking
│   │   ├── goals.py                  # Zielmanagement
│   │   ├── meetings.py               # Meetings, Journal
│   │   ├── announcements.py          # Ankündigungen
│   │   ├── messages.py               # Interne Nachrichten
│   │   ├── kpi_config.py             # KPI-Metadaten
│   │   ├── team.py                   # Teams
│   │   ├── audit.py                  # Audit-Logging
│   │   └── video_quiz.py             # Video-Quiz
│   ├── routers/                      # API-Endpoints (16 Module)
│   │   ├── auth.py                   # `/auth` — Login, Logout, Session-Verwaltung
│   │   ├── onboarding.py             # `/onboarding` — Kurse, Fortschritt, Admin-Editor (~2580 Zeilen)
│   │   ├── admin.py                  # `/admin` — Nutzer, Teams, Approvals, Exports (~830 Zeilen)
│   │   ├── tracking.py               # `/tracking` — Vertriebsplanung & KPIs
│   │   ├── recruiting.py             # `/recruiting` — Recruiting-Plan & Tracking
│   │   ├── goals.py                  # `/goals` — Zielmanagement
│   │   ├── meetings.py               # `/meetings` — Meetings & Journal
│   │   ├── announcements.py          # `/announcements` — Ankündigungen
│   │   ├── messages.py               # `/messages` — Interne Nachrichten
│   │   ├── video_quiz.py             # `/video-quiz` — Quiz-Management
│   │   ├── onboarding_dashboard.py   # `/onboarding-dashboard` — Starter-Übersicht
│   │   ├── kpi_config.py             # `/kpi-config` — KPI-Konfiguration
│   │   ├── admin_panels.py           # `/admin-panels` — Admin-Dashboard-Daten
│   │   ├── search.py                 # `/search` — Suchfunktion
│   │   ├── notifications.py          # `/notifications` — Benachrichtigungen
│   │   └── users.py                  # `/users` — Benutzerprofil
│   ├── services/                     # Geschäftslogik
│   │   ├── auth.py                   # Session-Auth, CSRF, Bcrypt, Audit
│   │   ├── security.py               # Input-Validierung, CSP, Security-Header
│   │   ├── storage.py                # Pluggable Storage (Local / Supabase)
│   │   ├── sales_planning.py         # Vertriebsplanung-Berechnungen
│   │   └── db_helpers.py             # TOCTOU-Guard (flush_or_conflict)
│   ├── scripts/                      # Hilfsskripte
│   │   └── seed_data.py              # Testdaten-Generator
│   ├── tests/                        # pytest (async, SQLite in-memory)
│   ├── config.py                     # Pydantic Settings (20 Variablen)
│   ├── database.py                   # Async Engine, Session-Maker, Pool-Config
│   ├── main.py                       # App-Einstiegspunkt, Router-Registrierung, Lifespan
│   ├── requirements.txt              # Python-Abhängigkeiten (gepinnt)
│   ├── Dockerfile                    # Backend-Container-Build
│   └── alembic.ini                   # Alembic-Konfiguration
│
├── frontend/                         # React 18 + TypeScript + Vite
│   ├── src/
│   │   ├── pages/                    # 21 Seitenkomponenten (19 im Root + 2 in onboarding/)
│   │   │   ├── StarterDashboard.tsx  # Starter-Überblick
│   │   │   ├── VertriebssteuerungPage.tsx  # Vertriebssteuerung (alle Rollen)
│   │   │   ├── AdminTabbedDashboard.tsx    # Admin-Panel (Nutzer, Teams, KPI, Branding, Audit)
│   │   │   ├── OnboardingEntryPage.tsx     # Onboarding-Einstieg (Kategorien)
│   │   │   ├── OnboardingCoursePage.tsx    # Kurs-Player (Video + Quiz + PDF)
│   │   │   ├── AdminOnboardingPage.tsx     # Onboarding-Editor (Admin)
│   │   │   ├── LeaderStarterfuehrungPage.tsx # Starterführung (Teamleiter/Admin)
│   │   │   ├── LeaderRecruitingPage.tsx    # Recruiting-Tracking
│   │   │   ├── TodoPlannerPage.tsx         # Persönliche To-do-Liste (Starter)
│   │   │   ├── InboxPage.tsx               # Nachrichten
│   │   │   ├── AnnouncementsPage.tsx       # Ankündigungen
│   │   │   ├── Login.tsx                   # Login-Formular
│   │   │   ├── Register.tsx                # Registrierung
│   │   │   └── ...weitere Seiten
│   │   ├── components/               # Komponenten-Bibliothek
│   │   │   ├── ui/                   # Primitives (Button, Card, Input, Select, etc.)
│   │   │   ├── admin/                # Admin-Tabs + Onboarding-Editor-Sub-Tree
│   │   │   ├── onboarding/           # OnboardingPlanView, LevelBadge, ProgressRing, etc.
│   │   │   ├── Layout.tsx            # Main Wrapper mit rollenbasierter Sidebar
│   │   │   ├── Topbar.tsx            # Kopfzeile mit Suche & Benachrichtigungen
│   │   │   ├── YouTubePlayer.tsx     # Video-Player (Mindest-Ansichtszeit-Gating)
│   │   │   └── ...weitere
│   │   ├── hooks/                    # useAuth, useQuery, etc.
│   │   ├── types/                    # TypeScript-Interfaces
│   │   ├── utils/                    # apiFetch (CSRF-Wrapper), levelInfo, watchGating, etc. + Tests
│   │   ├── locales/                  # i18n Translations (DE/EN/CS, ~990 Keys)
│   │   └── App.tsx                   # Router-Setup (React Router v6)
│   ├── public/                       # Static Assets
│   ├── nginx.conf                    # nginx-Konfiguration (Reverse Proxy, SSL, SPA-Routing)
│   ├── vite.config.ts                # Vite-Konfiguration (Dev-Proxy, Path-Alias)
│   ├── tailwind.config.js            # Tailwind (Brand: crimson #c1121f + Category-Paletten)
│   ├── tsconfig.json                 # TypeScript (strict mode)
│   ├── package.json                  # Node.js-Abhängigkeiten
│   └── Dockerfile                    # Frontend-Container-Build
│
├── scripts/
│   ├── dev.sh                        # Automatisiertes Development-Setup
│   └── deploy/                       # Deployment-Hilfsskripte
├── ssl/                              # TLS-Zertifikate (nicht im Git)
├── docs/                             # Dokumentation
│   ├── README.md                     # Dokumentations-Index
│   ├── ARCHITECTURE.md               # Detaillierte Architektur
│   ├── CODEMAP.md                    # 🤖 Auto-generiert
│   ├── DATA_MODEL.md                 # 🤖 Auto-generiert
│   ├── API.md                        # 🤖 Auto-generiert
│   └── ROUTES.md                     # 🤖 Auto-generiert
├── .github/workflows/                # CI/CD-Pipelines
├── Dockerfile                        # Single-Container-Build (HF Spaces)
├── docker-compose.yml                # Local Development (SQLite)
├── docker-compose.prod.yml           # Production (PostgreSQL + nginx + SSL)
├── .env.prod.example                 # Produktions-Umgebungsvorlage
├── CLAUDE.md                         # Entwickler-Dokumentation
├── Spec.md                           # 📋 Fachliche Spezifikation (Quelle der Wahrheit)
└── README.md                         # Diese Datei

Standard-Zugangsdaten

Nach Ausführung von seed_data.py oder beim ersten Docker-Start:

Rolle	E-Mail	Passwort
Admin	`admin@onboarding.de`	`admin123`

⚠️ SICHERHEITSWARNUNG: Ändern Sie das Admin-Passwort sofort nach der ersten Anmeldung in jeder Nicht-Entwicklungsumgebung!

Zielarchitektur (geplant)

Status: In Umsetzung (dokumentiert in Spec.md, Kapitel 9)

Die strategische Richtung ist die Ablösung aller externen Abhängigkeiten durch SLS-interne Integration:

Authentifizierung: MS Entra ID (OIDC) — ✅ andock-bereit: Token-Validierung (RS256/JWKS), Benutzerbindung über oid, Rollen-Matching (Entra-App-Rollen/Gruppen → Portal-Rollen, dynamisch per Admin-UI konfigurierbar). Aktivierung per AUTH_PROVIDER=oidc
Berechtigungsmodell: Zweidimensionales SLS-AT-Konzept (Firmenknoten + Büroknoten, Rollen = Aktionsmengen, Datenobjekte, jährlicher Review) — ✅ implementiert inkl. Admin-UI
Datenhaltung: Internes PostgreSQL (statt Supabase Postgres)
Dateispeicher: SLS-interner Objektspeicher/Fileshare (statt Supabase Storage) — pluggable StorageBackend vorbereitet
Hosting: SLS-interne Container-Plattform (Rückbau von HF-Spaces, Watchtower)

Detaillierte Planung: Spec.md, Kapitel 9; Anbindung Schritt für Schritt: docs/integration/SLS-IT-INTEGRATION.md.

Fehlerbehebung

Datenbankverbindung schlägt fehl

# Prüfen Sie DATABASE_URL
docker compose -f docker-compose.prod.yml logs db

# Prüfen Sie, ob PostgreSQL läuft
docker compose -f docker-compose.prod.yml ps db

# Stellen Sie sicher, dass DB_PASSWORD korrekt ist (keine Sonderzeichen ohne URL-Encoding)

Migrationen schlagen fehl

# Backend-Logs prüfen
docker compose -f docker-compose.prod.yml logs backend

# Bei Fehler: Korrupt-Status mit alembic stamp beheben
cd backend
alembic stamp head
alembic upgrade head

Frontend zeigt leere Seite

# Prüfen Sie Node-Build-Log
docker compose -f docker-compose.prod.yml logs frontend

# Prüfen Sie, ob Frontend-Files im Container existieren
docker exec onboarding-frontend ls /usr/share/nginx/html/

Login schlägt fehl

# Testdaten nicht geladen?
docker compose -f docker-compose.prod.yml logs backend | grep -i seed

# Stellen Sie sicher, dass SECRET_KEY in .env gesetzt ist

CORS-Fehler

# Prüfen Sie CORS_ORIGINS in .env
# Format muss JSON-Array sein: ["https://ihre-domain.at"]
# Achten Sie auf http vs. https und Ports

SSL-Fehler

# Zertifikate existieren?
ls -la ssl/

# Dateien müssen fullchain.pem und privkey.pem heißen
# Berechtigungen prüfen: docker exec onboarding-frontend cat /etc/nginx/ssl/fullchain.pem

Tech-Stack

Komponente	Technologie	Version	Zweck
Backend-Framework	FastAPI	0.109.0	REST-API mit async-Unterstützung
ASGI-Server	uvicorn	0.27.0	Produktions-Webserver
ORM	SQLAlchemy	2.0.25	Asynchroner Datenbankzugriff (async-native)
Migrationen	Alembic	1.13.1	Datenbank-Schemaversionierung
Authentifizierung	bcrypt	4.1.2	Passwort-Hashing (12 Runden)
Session-Signierung	itsdangerous	2.1.2	Signierte Session-Cookies (8h TTL)
Rate-Limiting	slowapi	0.1.9	Login-Brute-Force-Schutz (5/min)
Datenbank (Dev)	SQLite	(system)	Lokale Entwicklung
Datenbank (Prod)	PostgreSQL	16-alpine	Produktionsdatenbank
PostgreSQL-Treiber	asyncpg	0.29.0	Asynchroner Treiber
Frontend-Framework	React	18.3.x	UI-Bibliothek
Typsystem	TypeScript	5.6.x	Statische Typisierung
Build-Tool	Vite	6.0.x	Frontend-Bundler und Dev-Server
CSS-Framework	Tailwind CSS	3.4.x	Utility-First-CSS
Server-State-Management	React Query	5.17.x	Caching und Synchronisierung
Icons	lucide-react	0.323.x	Icon-Bibliothek
Internationalisierung	i18next	26.1.x	Lokalisierung (DE/EN/CS)
Reverse Proxy	nginx	alpine	SSL-Terminierung, Routing
Container-Runtime	Docker	≥ 24.0	Containerisierung
Backend-Tests	pytest	7.4.4	Test-Framework (async, SQLite in-memory)
Frontend-Tests	Vitest	2.1.x	Test-Framework (Utilities)
Basis-Image (Backend)	python:3.12-slim	—	Python-Laufzeitumgebung
Basis-Image (Frontend-Build)	node:20-alpine	—	Node.js-Buildumgebung
Basis-Image (Frontend-Runtime)	nginx:alpine	—	nginx-Webserver

Lizenz

MIT

Name		Name	Last commit message	Last commit date
Latest commit History 298 Commits
.github/workflows		.github/workflows
backend		backend
docs		docs
frontend		frontend
scripts		scripts
ssl		ssl
.dockerignore		.dockerignore
.env.prod.example		.env.prod.example
.gitignore		.gitignore
Dockerfile		Dockerfile
README.md		README.md
docker-compose.prod.yml		docker-compose.prod.yml
docker-compose.yml		docker-compose.yml

Folders and files

Latest commit

History

Repository files navigation

Onboarding Dashboard

Inhaltsverzeichnis

Überblick

Säule 1: Lernreise (Onboarding)

Säule 2: Vertriebssteuerung und Recruiting

Säule 3: Team-Führung

Dokumentation

Architektur

Komponenten

Proxy-Verhalten

Voraussetzungen

Für Docker-Deployment (empfohlen)

Für manuelle/Entwicklungs-Installation

Schnellstart (Entwicklung)

Mit scripts/dev.sh (automatisiert, empfohlen)

Manuelle Einzelschritte

Docker-Deployment

Entwicklung (docker-compose.yml)

Produktion (docker-compose.prod.yml)

Single-Container (Hugging Face Spaces)

Umgebungsvariablen

Datenbank-Setup und Migrationen

SQLite (Entwicklung)

PostgreSQL (Produktion)

Migrationen

Initiale Testdaten

SSL-Konfiguration

Selbstsigniertes Zertifikat für Tests

Zertifikat für Produktion

Projektstruktur

Standard-Zugangsdaten

Zielarchitektur (geplant)

Fehlerbehebung

Datenbankverbindung schlägt fehl

Migrationen schlagen fehl

Frontend zeigt leere Seite

Login schlägt fehl

CORS-Fehler

SSL-Fehler

Tech-Stack

Lizenz

About

Resources

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Packages