Initial commit: Waldseilgarten CRM Project Documentation

- README with project overview
- TDD (Technical Design Document)
- AI Council Review with critical analysis
- User Stories (27 stories, 120 SP)
- Architecture documentation

Stack: NestJS + React + PostgreSQL + Redis
Server: waldseilgarten (85.199.86.188)
This commit is contained in:
Henry
2026-03-14 14:33:02 +00:00
commit 28952b6c5f
5 changed files with 1937 additions and 0 deletions

140
README.md Normal file
View File

@@ -0,0 +1,140 @@
# Waldseilgarten Herrenberg CRM
**Ein modernes CRM- und Projektmanagementsystem für den Waldseilgarten Herrenberg**
---
## 🎯 Projekt-Übersicht
Das Waldseilgarten CRM ist eine maßgeschneiderte Lösung für das Kunden- und Projektanagement des Waldseilgarten Herrenberg. Es vereint CRM-Funktionalitäten mit Projektmanagement, Dokumentenverwaltung und E-Mail-Integration.
### Kernfunktionen
| Modul | Status | Beschreibung |
|-------|--------|--------------|
| 🔐 Authentifizierung | ✅ Geplant | JWT-basierte Auth mit Rollen |
| 👥 Kundenverwaltung | ✅ Geplant | Firmen, Ansprechpartner, Historie |
| 📁 Projektmanagement | ✅ Geplant | Projekte, Aufgaben, Meilensteine |
| 📄 Dokumentenverwaltung | ✅ Geplant | Upload, Versionierung, SeaDrive |
| 📧 E-Mail-Integration | ✅ Geplant | IMAP-Sync, Zuordnung |
| 📅 Kalender-Integration | ✅ Geplant | Google Calendar Sync |
---
## 🏗️ Tech Stack
### Backend
- **Framework:** NestJS (Node.js)
- **Datenbank:** PostgreSQL 18
- **Cache:** Redis 7
- **ORM:** TypeORM
- **Auth:** Passport + JWT
### Frontend
- **Framework:** React 19 + TypeScript
- **Build:** Vite
- **UI:** shadcn/ui + Tailwind CSS
- **State:** Zustand
- **Queries:** TanStack Query
### DevOps
- **Container:** Podman
- **Orchestrierung:** podman-compose
- **Reverse Proxy:** Traefik
- **SSL:** Let's Encrypt
---
## 📁 Projektstruktur
```
waldseilgarten-herrenberg-crm/
├── docs/
│ ├── TDD.md # Technical Design Document
│ ├── AI_COUNCIL_REVIEW.md # Architektur-Review
│ ├── USER_STORIES.md # Anforderungen
│ └── ARCHITECTURE.md # Systemarchitektur
├── src/ # Source Code (wird vom Server gespiegelt)
├── tests/ # Test-Suite
├── config/ # Konfigurationsdateien
└── README.md # Diese Datei
```
---
## 🚀 Schnellstart
### Voraussetzungen
- Podman installiert
- Zugriff auf Server: `waldseilgarten` (85.199.86.188)
### Deployment
```bash
# Auf dem Server (waldseilgarten)
ssh b0rbor4d@85.199.86.188
cd ~/projects/waldseilgarten-crm
# Container starten
podman-compose up -d
# Status prüfen
podman ps
```
### URLs
| Service | URL |
|---------|-----|
| Frontend | https://crm.waldseilgarten-herrenberg.de |
| API | https://api.waldseilgarten-herrenberg.de |
| Traefik | https://traefik.waldseilgarten-herrenberg.de |
---
## 📋 Dokumentation
- **[TDD](docs/TDD.md)** - Technisches Design-Dokument
- **[AI Council Review](docs/AI_COUNCIL_REVIEW.md)** - Kritisches Architektur-Review
- **[User Stories](docs/USER_STORIES.md)** - Detaillierte Anforderungen
- **[Architektur](docs/ARCHITECTURE.md)** - Systemarchitektur & Datenfluss
---
## 🗓️ Roadmap
### Phase 1: Foundation (Woche 1-3)
- ✅ User Auth
- ✅ Kundenverwaltung
- ✅ Projektmanagement
- ✅ Dashboard
### Phase 2: Dokumente (Woche 4)
- 🔄 Upload & Download
- 🔄 Lokale Speicherung
### Phase 3: Aufgaben (Woche 5)
- ⏳ Task-Management
- ⏳ Kanban-Board
### Phase 4: E-Mail (Woche 6-7)
- ⏳ IMAP-Integration
- ⏳ E-Mail-Zuordnung
### Phase 5: Erweiterungen (Woche 8-11)
- ⏳ Google Calendar
- ⏳ SeaDrive Sync
- ⏳ Reporting
---
## 👥 Kontakt
**Entwicklung:** Insight-IT GmbH
**Kunde:** Waldseilgarten Herrenberg
**Stand:** März 2026
---
## 📜 Lizenz
MIT © 2026 Florian Hartmann / Waldseilgarten Herrenberg

370
docs/AI_COUNCIL_REVIEW.md Normal file
View File

@@ -0,0 +1,370 @@
# AI Council Review
# Waldseilgarten Herrenberg CRM
**Sitzung:** 2026-03-14
**Reviewer:** AI Council (interne Rollen)
**Dokument:** TDD v1.0
---
## 🎭 Rollenverteilung
| Rolle | Persönlichkeit | Aufgabe |
|-------|----------------|---------|
| **🦅 Architekt** | Visionär, großes Bild | Gesamtstruktur, Skalierung |
| **🔍 Skeptiker** | Kritisch, Detailorientiert | Schwachstellen finden |
| **⚡ Pragmatiker** | Praktisch, erfahren | Umsetzbarkeit prüfen |
| **🛡️ Security-Experte** | Paranoid, gründlich | Sicherheitsrisiken |
| **💰 Product-Manager** | Nutzerfokus, ROI | Geschäftswert |
---
## 1. Executive Summary
**Gesamturteil:****GO für Phase 1** mit kleineren Anpassungen
Der vorgeschlagene Stack (NestJS + React) ist solide und passt zum Skill-Level der vorhandenen Entwicklung. Die modulare Architektur ermöglicht iteratives Vorgehen.
**Kritische Punkte:**
- SeaDrive-Integration als Optional markieren (hohe Komplexität)
- IMAP-Worker früh testen (potenzielles Risiko)
- Google Calendar OAuth gut dokumentieren
---
## 2. Detaillierte Reviews
### 🦅 Architektur-Review
**Stärken:**
- ✅ Klare Modularität durch NestJS
- ✅ API-First Ansatz
- ✅ TypeScript durchgehend
- ✅ Container-Setup solide
**Empfehlungen:**
1. **CQRS für Reports erwägen**
- Aktuell: Direkte DB-Queries
- Besser: Read-Models für komplexe Reports
- Grund: Performance bei großen Datenmengen
2. **Event-Driven Architecture**
- Statt: Direkte Service-Aufrufe
- Besser: Events für Cross-Cutting Concerns
- Beispiel: `ProjectCreatedEvent` → EmailNotification
3. **Caching-Strategie definieren**
- Redis für Sessions ✅
- Zusätzlich: Query-Result-Caching
- TTL-Strategie dokumentieren
**Bewertung:** 8/10
---
### 🔍 Skeptiker-Review
**Probleme identifiziert:**
#### 1. **IMAP-Integration unterschätzt?**
```
Problem: IMAP ist komplexer als gedacht
- Verschiedene Server-Implementierungen
- Connection-Handling bei Timeouts
- Sync-Strategie (Delta vs. Full)
Empfehlung:
- Proof-of-Concept in Woche 1
- Library: imapflow (moderner als node-imap)
- Fallback: Manuelle E-Mail-Erfassung
```
#### 2. **SeaDrive = Hohe Komplexität**
```
Problem: SeaDrive/Seafile Integration
- FUSE-Filesystem im Container
- Rechte-Management komplex
- Sync-Konflikte
Empfehlung:
- Als "Phase 2+" markieren
- Alternative: S3-kompatible API
- Oder: Seafile REST API direkt nutzen
```
#### 3. **Fehlende Rate-Limiting**
```
Problem: Keine API-Rate-Limits definiert
- Login-Endpunkte vulnerable
- Upload-Endpunkten ohne Limits
Empfehlung:
- nestjs-rate-limiter hinzufügen
- Spezifische Limits pro Endpoint:
- /auth/login: 5/min pro IP
- /upload: 10/min pro User
```
#### 4. **Fehlende Input-Validierung Details**
```
Problem: "class-validator" erwähnt, aber keine Details
- Welche Decorators?
- Custom Validators?
Empfehlung:
- @IsEmail() für E-Mails
- @Length() für Passwörter (min 8)
- @Matches() für komplexe Regeln
- Sanitization (XSS-Prevention)
```
**Bewertung:** 6/10 (wichtige Details fehlen)
---
### ⚡ Pragmatiker-Review
**Umsetzbarkeit:** ✅ Gut
**Zeitschätzungen:**
| Phase | TDD-Schätzung | Realistisch | Risiko |
|-------|---------------|-------------|--------|
| Phase 1 | 2-3 Wochen | 3-4 Wochen | Mittel |
| Phase 2 | 1 Woche | 1-2 Wochen | Niedrig |
| Phase 3 | 1 Woche | 1 Woche | Niedrig |
| Phase 4 | 2 Wochen | 3-4 Wochen | Hoch |
| Phase 5 | 4-5 Wochen | 6-8 Wochen | Mittel |
**Gesamt:** 11 Wochen → **Realistisch: 14-18 Wochen**
**Empfehlungen:**
1. **MVP reduzieren**
```
Statt:
- Multi-Tenant
- SSO
- 2FA
Zuerst:
- Single-Tenant
- Lokale Auth
- Einfaches Passwort
```
2. **Feature-Flags nutzen**
```typescript
// Statt: Code auskommentieren
if (config.features.emailIntegration) {
// IMAP-Feature
}
```
3. **Vorhandenen Code nutzen**
- Backend ist bereits teilweise implementiert
- Frontend existiert bereits
- Fokus: Integration & Bugfixing
**Bewertung:** 7/10
---
### 🛡️ Security-Review
**Kritisch:**
#### 1. **JWT-Secret in .env**
```
Problem: JWT_SECRET in docker-compose.yml sichtbar
Risiko: Bei Repo-Leak kompromittiert
Empfehlung:
- Docker Secrets oder
- Environment-Injection bei Deployment
- Regelmäßige Rotation (alle 90 Tage)
```
#### 2. **Fehlende SQL-Injection Tests**
```
Problem: TypeORM schützt, aber keine expliziten Tests
Empfehlung:
- Test-Cases für:
- ' OR '1'='1
- UNION SELECT
- Time-based Blind SQLi
```
#### 3. **File Upload Security**
```
Problem: Upload-Endpunkte ohne Details
Risiken:
- MIME-Type spoofing
- Path traversal
- Malware-Upload
Empfehlung:
- Magic-Bytes-Check (nicht nur Extension)
- ClamAV-Integration
- Upload-Verzeichnis außerhalb Webroot
- Dateigrößen-Limit (10MB)
```
#### 4. **CORS zu offen?**
```yaml
# Aktuell:
CORS_ORIGINS: "*"
# Besser:
CORS_ORIGINS: "https://waldseilgarten-herrenberg.de"
```
#### 5. **Fehlende Audit-Logs**
```
Problem: Wer hat wann was gemacht?
Empfehlung:
- Audit-Log Tabelle
- Loggen: Login, Daten-Änderungen, Löschungen
- Unveränderlich speichern
```
**Bewertung:** 5/10 (mehrere kritische Lücken)
---
### 💰 Product-Manager-Review
**Geschäftswert:** ✅ Hoch
**Nutzer-Jobs:**
| Job | Wichtigkeit | Erfüllung im TDD |
|-----|-------------|------------------|
| Kunden finden | Kritisch | ✅ Gut |
| Projekte verfolgen | Kritisch | ✅ Gut |
| Dokumente ablegen | Wichtig | ✅ Gut |
| E-Mails zuordnen | Wichtig | ⚠️ Komplex |
| Termine syncen | Nice-to-have | ⚠️ Optional |
**Konkurrenz-Analyse:**
- HubSpot: Zu teuer, zu komplex
- Pipedrive: Gut, aber nicht self-hosted
- **Dieses CRM:** Perfekte Nische
**Empfehlungen:**
1. **Onboarding-Flow**
```
Fehlt im TDD:
- Erstkonfiguration Wizard
- Beispieldaten generieren
- Tutorial/Tour
```
2. **Mobile-First nicht vergessen**
```
TDD erwähnt PWA, aber:
- Keine Mobile-Optimierung Details
- Touch-Gestures?
- Offline-Modus?
```
3. **Export-Funktion**
```
Kritisch für Kunden:
- "Meine Daten gehören mir"
- CSV/Excel Export
- JSON-Export für Migration
```
**Bewertung:** 7/10
---
## 3. Konsens-Empfehlungen
### ✅ Beibehalten
- NestJS + React Stack
- PostgreSQL + Redis
- Modulare Architektur
- Docker/Podman Setup
### 🔄 Anpassen
#### 1. **SeaDrive → Optional**
```
Statt: Pflicht-Feature
Besser: Phase 2+ mit Fallback
```
#### 2. **IMAP zuerst testen**
```
Aktion: Proof-of-Concept in Woche 1
Falls zu komplex: Manuelle Erfassung
```
#### 3. **Security Hardening**
```
Muss:
- Rate-Limiting
- JWT-Secret-Management
- File-Upload Security
- Audit-Logging
```
#### 4. **Zeitplan realistisch**
```
Statt: 11 Wochen
Realistisch: 14-18 Wochen
```
### ❌ Hinzufügen
| Feature | Priorität | Aufwand |
|---------|-----------|---------|
| Rate-Limiting | Kritisch | Klein |
| Audit-Logging | Hoch | Mittel |
| Feature-Flags | Hoch | Klein |
| Data-Export | Hoch | Klein |
| API-Doku (Swagger) | Mittel | Klein |
---
## 4. Final Voting
| Rolle | Score | Verdict |
|-------|-------|---------|
| 🦅 Architekt | 8/10 | ✅ GO |
| 🔍 Skeptiker | 6/10 | ⚠️ GO mit Bedenken |
| ⚡ Pragmatiker | 7/10 | ✅ GO |
| 🛡️ Security | 5/10 | ⚠️ GO nach Hardening |
| 💰 Product | 7/10 | ✅ GO |
### **Endergebnis: 6.6/10** → ✅ **GO mit Anpassungen**
---
## 5. Action Items
| # | Aufgabe | Verantwortlich | Deadline |
|---|---------|----------------|----------|
| 1 | Rate-Limiting implementieren | Backend | Phase 1 |
| 2 | IMAP Proof-of-Concept | Backend | Woche 1 |
| 3 | Security-Checkliste erstellen | Security | Vor Deployment |
| 4 | SeaDrive als Optional markieren | PM | Dokumentation |
| 5 | Zeitplan anpassen (14-18 Wochen) | PM | Roadmap |
| 6 | Feature-Flags Setup | Architekt | Phase 1 |
---
## 6. Follow-Up Review
**Termin:** Nach Phase 1 Completion
**Ziel:** Validierung der Annahmen, Anpassung für Phasen 2-5
---
**Review abgeschlossen:** 2026-03-14
**Nächster Schritt:** TDD anpassen basierend auf Empfehlungen

541
docs/ARCHITECTURE.md Normal file
View File

@@ -0,0 +1,541 @@
# Systemarchitektur
# Waldseilgarten Herrenberg CRM
**Version:** 1.0
**Datum:** 2026-03-14
---
## 1. Architektur-Übersicht
Das Waldseilgarten CRM folgt einer **Layered Architecture** mit klaren Trennungen zwischen:
- **Presentation Layer** (React Frontend)
- **API Layer** (NestJS Controllers)
- **Business Layer** (NestJS Services)
- **Data Layer** (TypeORM + PostgreSQL)
```
┌─────────────────────────────────────────────────────────────────┐
│ PRESENTATION LAYER │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ React │ │ Zustand │ │ TanStack │ │
│ │ Components │ │ Store │ │ Query │ │
│ └──────┬──────┘ └─────────────┘ └─────────────┘ │
│ │ │
│ ▼ HTTPS │
├─────────────────────────────────────────────────────────────────┤
│ API LAYER │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ NestJS Controllers │ │
│ │ ┌─────────┐ ┌──────────┐ ┌─────────┐ ┌──────────┐ │ │
│ │ │ Auth │ │ Customers│ │ Projects│ │Documents │ │ │
│ │ │Controller│ │Controller│ │Controller│ │Controller│ │ │
│ │ └────┬────┘ └────┬─────┘ └────┬────┘ └────┬─────┘ │ │
│ └───────┼───────────┼────────────┼───────────┼───────────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
├─────────────────────────────────────────────────────────────────┤
│ BUSINESS LAYER │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ NestJS Services │ │
│ │ ┌─────────┐ ┌──────────┐ ┌─────────┐ ┌──────────┐ │ │
│ │ │ Auth │ │ Customers│ │ Projects│ │Documents │ │ │
│ │ │ Service │ │ Service │ │ Service │ │ Service │ │ │
│ │ └────┬────┘ └────┬─────┘ └────┬────┘ └────┬─────┘ │ │
│ └───────┼───────────┼────────────┼───────────┼───────────┘ │
│ │ │ │ │ │
│ ▼ ▼ ▼ ▼ │
├─────────────────────────────────────────────────────────────────┤
│ DATA LAYER │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ TypeORM Repository │ │
│ └─────────────────────────┬───────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ PostgreSQL 18 │ │
│ └─────────────────────────────────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌─────────────────────────────────────────────────────────┐ │
│ │ Redis 7 │ │
│ │ (Cache / Sessions) │ │
│ └─────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────┘
```
---
## 2. Backend-Architektur
### 2.1 Modulstruktur
```
backend/src/
├── app.module.ts # Root-Modul
├── main.ts # Bootstrap
├── common/ # Shared Resources
│ ├── decorators/
│ ├── filters/ # Exception Filters
│ ├── guards/ # Auth Guards
│ ├── interceptors/ # Logging, Transform
│ └── pipes/ # Validation Pipes
├── config/ # Konfiguration
│ ├── database.config.ts
│ ├── app.config.ts
│ └── redis.config.ts
├── auth/ # Phase 1
│ ├── auth.module.ts
│ ├── auth.controller.ts
│ ├── auth.service.ts
│ ├── dto/
│ │ ├── login.dto.ts
│ │ └── register.dto.ts
│ ├── entities/
│ │ └── user.entity.ts
│ └── guards/
│ └── jwt-auth.guard.ts
├── customers/ # Phase 1
│ ├── customers.module.ts
│ ├── customers.controller.ts
│ ├── customers.service.ts
│ ├── dto/
│ │ ├── create-customer.dto.ts
│ │ └── update-customer.dto.ts
│ └── entities/
│ ├── customer.entity.ts
│ └── contact.entity.ts
├── projects/ # Phase 1
│ ├── projects.module.ts
│ ├── projects.controller.ts
│ ├── projects.service.ts
│ ├── dto/
│ └── entities/
│ ├── project.entity.ts
│ └── project-member.entity.ts
├── documents/ # Phase 2
│ ├── documents.module.ts
│ ├── documents.controller.ts
│ ├── documents.service.ts
│ ├── storage/
│ │ ├── local.storage.ts
│ │ └── seadrive.storage.ts
│ └── entities/
│ └── document.entity.ts
├── tasks/ # Phase 3
│ ├── tasks.module.ts
│ ├── tasks.controller.ts
│ ├── tasks.service.ts
│ └── entities/
│ └── task.entity.ts
└── email/ # Phase 4
├── email.module.ts
├── email.controller.ts
├── email.service.ts
├── imap/
│ └── imap.service.ts
└── entities/
└── email.entity.ts
```
### 2.2 Request Flow
```
Request
┌─────────────┐
│ Traefik │ → SSL-Terminierung, Routing
└──────┬──────┘
┌─────────────┐
│ Middleware │ → CORS, Helmet, Compression
│ (Global) │
└──────┬──────┘
┌─────────────┐
│ Guards │ → JWT Validation
│ (Optional) │
└──────┬──────┘
┌─────────────┐
│ Pipes │ → DTO Validation
│ (Transform) │
└──────┬──────┘
┌─────────────┐
│ Controller │ → Route Handler
└──────┬──────┘
┌─────────────┐
│ Service │ → Business Logic
└──────┬──────┘
┌─────────────┐
│ Repository │ → TypeORM
└──────┬──────┘
┌─────────────┐
│ PostgreSQL │
└─────────────┘
```
---
## 3. Datenbank-Schema
### 3.1 Entity Relationship Diagram
```
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ users │ │ customers │ │ projects │
├──────────────┤ ├──────────────┤ ├──────────────┤
│ id (PK) │ │ id (PK) │ │ id (PK) │
│ email │◄──────┤ created_by │ │ customer_id │──────►
│ password_hash│ │ company_name │ │ name │
│ first_name │ │ industry │ │ description │
│ last_name │ │ website │ │ status │
│ role │ │ phone │ │ priority │
│ is_active │ │ email │ │ start_date │
│ created_at │ │ address │ │ end_date │
└──────────────┘ │ notes │ │ budget │
│ tags[] │ │ created_by │◄─────
│ created_at │ │ created_at │
└──────────────┘ └──────────────┘
│ │
│ │
▼ ▼
┌──────────────┐ ┌──────────────┐
│ contacts │ │project_members
├──────────────┤ ├──────────────┤
│ id (PK) │ │ id (PK) │
│ customer_id │──────►│ project_id │
│ first_name │ │ user_id │
│ last_name │ │ role │
│ email │ │ joined_at │
│ phone │ └──────────────┘
│ position │
│ is_primary │
└──────────────┘
```
### 3.2 Zusätzliche Tabellen (Spätere Phasen)
```
documents:
- id (PK)
- name
- original_name
- storage_path
- mime_type
- size_bytes
- project_id (FK)
- uploaded_by (FK)
- created_at
tasks:
- id (PK)
- title
- description
- status
- priority
- due_date
- project_id (FK)
- assigned_to (FK)
- created_by (FK)
emails:
- id (PK)
- message_id (IMAP)
- subject
- from_address
- to_addresses
- body_text
- body_html
- received_at
- project_id (FK, nullable)
- customer_id (FK, nullable)
```
---
## 4. Frontend-Architektur
### 4.1 Komponenten-Struktur
```
frontend/src/
├── components/
│ ├── ui/ # shadcn/ui Basis-Komponenten
│ │ ├── button.tsx
│ │ ├── input.tsx
│ │ ├── dialog.tsx
│ │ └── ...
│ │
│ ├── layout/ # Layout-Komponenten
│ │ ├── Sidebar.tsx
│ │ ├── Header.tsx
│ │ └── MainLayout.tsx
│ │
│ ├── forms/ # Formular-Komponenten
│ │ ├── CustomerForm.tsx
│ │ ├── ProjectForm.tsx
│ │ └── LoginForm.tsx
│ │
│ └── data-display/ # Daten-Visualisierung
│ ├── DataTable.tsx
│ ├── StatCard.tsx
│ └── ActivityFeed.tsx
├── pages/ # Route-Komponenten
│ ├── auth/
│ │ └── Login.tsx
│ ├── dashboard/
│ │ └── Dashboard.tsx
│ ├── customers/
│ │ ├── CustomerList.tsx
│ │ └── CustomerDetail.tsx
│ ├── projects/
│ │ ├── ProjectList.tsx
│ │ └── ProjectDetail.tsx
│ └── documents/
│ └── DocumentList.tsx
├── hooks/ # Custom Hooks
│ ├── useAuth.ts
│ ├── useCustomers.ts
│ └── useProjects.ts
├── services/ # API-Clients
│ └── api.ts # Axios-Instance
├── store/ # Zustand Store
│ ├── authStore.ts
│ └── uiStore.ts
├── types/ # TypeScript Types
│ └── index.ts
└── utils/ # Hilfsfunktionen
├── formatters.ts
└── validators.ts
```
### 4.2 State Management
```
┌──────────────────────────────────────────────────────┐
│ Zustand Store │
├──────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌──────────────┐ │
│ │ authStore │ │ uiStore │ │
│ │ │ │ │ │
│ │ • user │ │ • sidebar │ │
│ │ • token │ │ • theme │ │
│ │ • isAuth │ │ • notifications│ │
│ │ • login() │ │ • modalState │ │
│ │ • logout() │ │ • setTheme() │ │
│ └──────────────┘ └──────────────┘ │
│ │
└──────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────┐
│ TanStack Query │
│ (Server State) │
├──────────────────────────────────────────────────────┤
│ │
│ • useCustomers() → GET /api/customers │
│ • useCustomer(id) → GET /api/customers/:id │
│ • useCreateCustomer() → POST /api/customers │
│ • useUpdateCustomer() → PUT /api/customers/:id │
│ │
│ Features: │
│ • Caching │
│ • Background Refetching │
│ • Optimistic Updates │
│ • Error Handling │
│ │
└──────────────────────────────────────────────────────┘
```
---
## 5. Deployment-Architektur
### 5.1 Server-Layout
```
┌─────────────────────────────────────────────────────────────┐
│ Ubuntu 24.04 LTS │
│ (waldseilgarten) │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Podman Runtime │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌────────────┐ │ │
│ │ │ Traefik │ │ Backend │ │ Frontend │ │ │
│ │ │ :80/:443 │ │ :3001 │ │ :3000 │ │ │
│ │ └─────────────┘ └─────────────┘ └────────────┘ │ │
│ │ │ │
│ │ ┌─────────────┐ ┌─────────────┐ ┌────────────┐ │ │
│ │ │ PostgreSQL │ │ Redis │ │ Worker │ │ │
│ │ │ :5432 │ │ :6379 │ │ (IMAP) │ │ │
│ │ └─────────────┘ └─────────────┘ └────────────┘ │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────┐ │
│ │ Volumes │ │
│ │ │ │
│ │ ~/projects/waldseilgarten-crm/data/ │ │
│ │ ├── db/ → PostgreSQL Daten │ │
│ │ ├── redis/ → Redis Persistenz │ │
│ │ └── uploads/ → Dokumente │ │
│ │ │ │
│ └─────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
```
### 5.2 Netzwerk-Architektur
```
Internet
┌─────────────┐
│ Cloudflare │ (Optional: CDN, DDoS-Protection)
└──────┬──────┘
┌─────────────┐
│ Router │ 85.199.86.188
└──────┬──────┘
┌─────────────┐
│ Traefik │ Port 80/443
│ (Reverse │
│ Proxy) │
└──┬───────┬──┘
│ │
▼ ▼
┌──────┐ ┌──────┐
│:3000 │ │:3001 │
│Frontend│ │Backend│
└──────┘ └──────┘
```
---
## 6. Sicherheitsarchitektur
### 6.1 Authentifizierungs-Flow
```
┌─────────┐ ┌─────────┐
│ Client │ │ Server │
└────┬────┘ └────┬────┘
│ │
│ POST /api/auth/login │
│ { email, password } │
│───────────────────────────────────────▶│
│ │
│ │ bcrypt.compare()
│ │
│ { access_token, user } │
│◀───────────────────────────────────────│
│ │
│ Store in memory (Zustand) │
│ │
│ GET /api/customers │
│ Authorization: Bearer {token} │
│───────────────────────────────────────▶│
│ │
│ │ JWT.verify()
│ │
│ { customers } │
│◀───────────────────────────────────────│
│ │
```
### 6.2 Autorisierungs-Matrix
| Feature | Admin | Manager | User |
|---------|-------|---------|------|
| Benutzer verwalten | ✅ | ❌ | ❌ |
| Alle Kunden sehen | ✅ | ✅ | ✅ |
| Alle Projekte sehen | ✅ | ✅ | ⚠️* |
| Projekt anlegen | ✅ | ✅ | ❌ |
| Eigene Daten ändern | ✅ | ✅ | ✅ |
| Reports exportieren | ✅ | ✅ | ❌ |
| System-Einstellungen | ✅ | ❌ | ❌ |
*User sieht nur zugewiesene Projekte
---
## 7. Monitoring & Observability
### 7.1 Health Checks
```
GET /api/health
{
"status": "healthy",
"timestamp": "2026-03-14T14:30:00Z",
"version": "1.0.0",
"checks": {
"database": {
"status": "up",
"responseTime": "12ms"
},
"cache": {
"status": "up",
"responseTime": "3ms"
},
"storage": {
"status": "up",
"freeSpace": "45GB"
}
}
}
```
### 7.2 Logging-Struktur
```typescript
{
"timestamp": "2026-03-14T14:30:00Z",
"level": "info",
"context": "CustomersService",
"message": "Customer created",
"metadata": {
"customerId": "uuid",
"userId": "uuid",
"duration": "45ms"
},
"requestId": "req-uuid"
}
```
---
**Ende der Architektur-Dokumentation**

459
docs/TDD.md Normal file
View File

@@ -0,0 +1,459 @@
# Technical Design Document (TDD)
# Waldseilgarten Herrenberg CRM
**Version:** 1.0
**Datum:** 2026-03-14
**Autor:** AI-Assistent (Henry)
**Status:** Entwurf
---
## 1. Executive Summary
### 1.1 Ziel
Entwicklung eines modernen CRM- und Projektmanagementsystems für den Waldseilgarten Herrenberg mit Fokus auf:
- Kunden- und Kontaktverwaltung
- Projekt-Tracking
- Dokumentenmanagement
- E-Mail-Integration
### 1.2 Tech Stack
| Schicht | Technologie |
|---------|-------------|
| Backend | NestJS (Node.js 22) |
| Frontend | React 19 + Vite |
| Datenbank | PostgreSQL 18 |
| Cache | Redis 7 |
| Container | Podman |
| Proxy | Traefik |
### 1.3 Architekturprinzipien
- **Modularität:** Klare Trennung in Feature-Module
- **Type-Safety:** TypeScript durchgehend
- **API-First:** REST API als zentrale Schnittstelle
- **Containerized:** Vollständig containerisiert
---
## 2. Systemarchitektur
### 2.1 High-Level Architektur
```
┌─────────────────────────────────────────────────────────────┐
│ Client │
│ (React + Vite) │
└───────────────────────┬─────────────────────────────────────┘
│ HTTPS
┌───────────────────────▼─────────────────────────────────────┐
│ Traefik │
│ (Reverse Proxy + SSL) │
└───────────────────────┬─────────────────────────────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ Frontend │ │ Backend │ │ Worker │
│ (nginx) │ │ (NestJS) │ │ (IMAP) │
│ :3000 │ │ :3001 │ │ │
└──────────────┘ └──────┬───────┘ └──────────────┘
┌───────────────┼───────────────┐
▼ ▼ ▼
┌──────────────┐ ┌──────────────┐ ┌──────────────┐
│ PostgreSQL │ │ Redis │ │ Local │
│ (DB) │ │ (Cache) │ │ Storage │
│ :5432 │ │ :6379 │ │ │
└──────────────┘ └──────────────┘ └──────────────┘
```
### 2.2 Backend-Module
```
backend/src/
├── auth/ # Phase 1: Authentifizierung
├── customers/ # Phase 1: Kundenverwaltung
├── projects/ # Phase 1: Projektmanagement
├── dashboard/ # Phase 1: Statistiken
├── documents/ # Phase 2: Dokumentenverwaltung
├── tasks/ # Phase 3: Aufgabenmanagement
├── email/ # Phase 4: E-Mail-Integration
├── calendar/ # Phase 5: Google Calendar
└── common/ # Shared Utilities
```
### 2.3 Datenbank-Schema (Phase 1)
```sql
-- Users
CREATE TABLE users (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
email VARCHAR(255) UNIQUE NOT NULL,
password_hash VARCHAR(255) NOT NULL,
first_name VARCHAR(100),
last_name VARCHAR(100),
role VARCHAR(20) DEFAULT 'user',
is_active BOOLEAN DEFAULT true,
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
);
-- Customers
CREATE TABLE customers (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
company_name VARCHAR(255) NOT NULL,
industry VARCHAR(100),
website VARCHAR(255),
phone VARCHAR(50),
email VARCHAR(255),
address TEXT,
notes TEXT,
tags TEXT[],
created_by UUID REFERENCES users(id),
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
);
-- Contacts (Ansprechpartner)
CREATE TABLE contacts (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
customer_id UUID REFERENCES customers(id) ON DELETE CASCADE,
first_name VARCHAR(100) NOT NULL,
last_name VARCHAR(100) NOT NULL,
email VARCHAR(255),
phone VARCHAR(50),
position VARCHAR(100),
is_primary BOOLEAN DEFAULT false,
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
);
-- Projects
CREATE TABLE projects (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
name VARCHAR(255) NOT NULL,
description TEXT,
customer_id UUID REFERENCES customers(id) ON DELETE SET NULL,
status VARCHAR(50) DEFAULT 'new',
priority VARCHAR(20) DEFAULT 'medium',
start_date DATE,
end_date DATE,
budget DECIMAL(12,2),
created_by UUID REFERENCES users(id),
created_at TIMESTAMP DEFAULT NOW(),
updated_at TIMESTAMP DEFAULT NOW()
);
-- Project Members
CREATE TABLE project_members (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
user_id UUID REFERENCES users(id) ON DELETE CASCADE,
role VARCHAR(50) DEFAULT 'member',
joined_at TIMESTAMP DEFAULT NOW(),
UNIQUE(project_id, user_id)
);
```
---
## 3. API-Design
### 3.1 Authentication
```typescript
// POST /api/auth/login
interface LoginRequest {
email: string;
password: string;
}
interface LoginResponse {
access_token: string;
user: {
id: string;
email: string;
first_name: string;
last_name: string;
role: string;
};
}
// POST /api/auth/register
interface RegisterRequest {
email: string;
password: string;
first_name: string;
last_name: string;
}
```
### 3.2 Customers
```typescript
// GET /api/customers
interface ListCustomersQuery {
page?: number;
limit?: number;
search?: string;
industry?: string;
tags?: string[];
}
// POST /api/customers
interface CreateCustomerRequest {
company_name: string;
industry?: string;
website?: string;
phone?: string;
email?: string;
address?: string;
notes?: string;
tags?: string[];
}
// GET /api/customers/:id
interface CustomerResponse {
id: string;
company_name: string;
industry?: string;
website?: string;
phone?: string;
email?: string;
address?: string;
notes?: string;
tags: string[];
contacts: Contact[];
projects: ProjectSummary[];
created_at: string;
updated_at: string;
}
```
### 3.3 Projects
```typescript
// POST /api/projects
interface CreateProjectRequest {
name: string;
description?: string;
customer_id?: string;
status?: 'new' | 'active' | 'on_hold' | 'completed' | 'cancelled';
priority?: 'low' | 'medium' | 'high' | 'urgent';
start_date?: string;
end_date?: string;
budget?: number;
}
// GET /api/projects/:id
interface ProjectResponse {
id: string;
name: string;
description?: string;
customer?: CustomerSummary;
status: string;
priority: string;
start_date?: string;
end_date?: string;
budget?: number;
members: ProjectMember[];
documents_count: number;
tasks_count: number;
created_at: string;
updated_at: string;
}
```
---
## 4. Sicherheit
### 4.1 Authentifizierung
- JWT-based Authentication
- Access Token: 24h Gültigkeit
- Refresh Token: 7 Tage Gültigkeit (optional)
- bcrypt für Passwort-Hashing (10 rounds)
### 4.2 Autorisierung
- Rollenbasierte Zugriffskontrolle (RBAC)
- Rollen: `admin`, `manager`, `user`
- Guards auf Controller-Ebene
### 4.3 Datenschutz
- HTTPS enforced
- SQL Injection Prevention (TypeORM)
- XSS Prevention (React escaping)
- CSRF Protection
---
## 5. Deployment
### 5.1 Container-Setup
```yaml
# docker-compose.yml
version: '3.8'
services:
postgres:
image: postgres:18-alpine
environment:
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
POSTGRES_DB: ${POSTGRES_DB}
volumes:
- ./data/db:/var/lib/postgresql/data
networks:
- crm-network
redis:
image: redis:7-alpine
command: redis-server --requirepass ${REDIS_PASSWORD}
volumes:
- ./data/redis:/data
networks:
- crm-network
backend:
build: ./backend
environment:
NODE_ENV: production
POSTGRES_HOST: postgres
REDIS_HOST: redis
labels:
- "traefik.enable=true"
- "traefik.http.routers.crm-api.rule=Host(`api.crm.waldseilgarten-herrenberg.de`)"
networks:
- crm-network
frontend:
build: ./frontend
labels:
- "traefik.enable=true"
- "traefik.http.routers.crm-frontend.rule=Host(`crm.waldseilgarten-herrenberg.de`)"
networks:
- crm-network
networks:
crm-network:
driver: bridge
```
### 5.2 Traefik-Konfiguration
```yaml
# traefik/dynamic/crm.yml
http:
routers:
crm-api:
rule: "Host(`api.waldseilgarten-herrenberg.de`)"
service: crm-api
entryPoints:
- websecure
tls:
certResolver: le
crm-frontend:
rule: "Host(`waldseilgarten-herrenberg.de`)"
service: crm-frontend
entryPoints:
- websecure
tls:
certResolver: le
services:
crm-api:
loadBalancer:
servers:
- url: "http://waldseilgarten-backend:3001"
crm-frontend:
loadBalancer:
servers:
- url: "http://waldseilgarten-frontend:3000"
```
---
## 6. Testing
### 6.1 Test-Strategie
- **Unit Tests:** Jest für Services
- **Integration Tests:** Supertest für API
- **E2E Tests:** Playwright für Frontend
### 6.2 Test-Abdeckung
- Mindestens 80% für kritische Pfade
- Auth-Flows vollständig testen
- API-Endpunkte validieren
---
## 7. Monitoring & Logging
### 7.1 Logging
- Structured Logging (Winston)
- Log-Level: ERROR, WARN, INFO, DEBUG
- Request-Logging via Middleware
### 7.2 Health Checks
```
GET /api/health
{
"status": "healthy",
"database": "connected",
"cache": "connected",
"version": "1.0.0"
}
```
---
## 8. Nicht-funktionale Anforderungen
| Anforderung | Ziel |
|-------------|------|
| Performance | API-Response < 200ms (p95) |
| Verfügbarkeit | 99.9% Uptime |
| Skalierung | Horizontal skalierbar |
| Backup | Tägliche DB-Backups |
| Wartung | Zero-Downtime Deployments |
---
## 9. Risiken & Mitigation
| Risiko | Wahrscheinlichkeit | Impact | Mitigation |
|--------|-------------------|--------|------------|
| IMAP-Integration komplex | Hoch | Mittel | Frühes Proof-of-Concept |
| SeaDrive-Kompatibilität | Mittel | Mittel | Fallback zu lokalem Storage |
| Performance bei vielen Dokumenten | Mittel | Hoch | Pagination, Lazy Loading |
| Browser-Kompatibilität | Niedrig | Niedrig | Moderne Browser voraussetzen |
---
## 10. Nächste Schritte
1. **Setup** (Tag 1)
- Repository initialisieren
- Docker-Compose Setup
- Datenbank-Migrations
2. **Phase 1: Auth** (Tag 2-3)
- Login/Register API
- JWT-Implementation
- Frontend Auth-Flow
3. **Phase 1: Kunden** (Tag 4-5)
- CRUD API
- Frontend Forms
- Listen-View
4. **Review** (Tag 6)
- Code Review
- Testing
- Deployment auf Staging
---
**Ende des TDD**

427
docs/USER_STORIES.md Normal file
View File

@@ -0,0 +1,427 @@
# User Stories
# Waldseilgarten Herrenberg CRM
**Dokument:** Anforderungsspezifikation
**Format:** Job Stories (Jobs-to-be-done)
**Priorität:** MoSCoW (Must/Should/Could/Won't)
---
## Phase 1: Foundation
### 🔐 Authentifizierung
#### US-001: Als Mitarbeiter möchte ich mich einloggen
```
Job: Mich im System authentifizieren
Akzeptanzkriterien:
- Login mit E-Mail und Passwort
- JWT-Token wird generiert
- Fehlerhafte Logins werden protokolliert
- Session läuft nach 24h ab
Priorität: MUST
Story Points: 3
```
#### US-002: Als Admin möchte ich neue Benutzer anlegen
```
Job: Team-Mitglieder dem System hinzufügen
Akzeptanzkriterien:
- E-Mail, Name, Rolle festlegen
- Automatische Willkommens-E-Mail
- Passwort-Reset-Link generieren
- Rollen: Admin, Manager, User
Priorität: MUST
Story Points: 3
```
#### US-003: Als Benutzer möchte ich mein Passwort ändern
```
Job: Meine Zugangsdaten verwalten
Akzeptanzkriterien:
- Altes Passwort zur Bestätigung
- Neues Passwort muss Richtlinien erfüllen (8 Zeichen, etc.)
- Alle Sessions werden invalidiert
Priorität: SHOULD
Story Points: 2
```
---
### 👥 Kundenverwaltung
#### US-101: Als User möchte ich einen neuen Kunden anlegen
```
Job: Eine neue Firma im System erfassen
Akzeptanzkriterien:
- Pflichtfelder: Firmenname
- Optional: Branche, Website, Telefon, E-Mail, Adresse
- Tags hinzufügen (z.B. "VIP", "Langjährig")
- Automatische Kundennummer generieren
- Duplikat-Erkennung (ähnliche Namen warnen)
Priorität: MUST
Story Points: 5
```
#### US-102: Als User möchte ich Kunden suchen
```
Job: Schnell einen Kunden finden
Akzeptanzkriterien:
- Volltextsuche über Firmenname
- Filter: Branche, Tags, Erstellungsdatum
- Sortierung: Name, Datum, letzte Aktivität
- Pagination (20 pro Seite)
Priorität: MUST
Story Points: 5
```
#### US-103: Als User möchte ich Kundendetails ansehen
```
Job: Alle Informationen zu einem Kunden einsehen
Akzeptanzkriterien:
- Übersicht: Stammdaten, Kontakte, Projekte
- Aktivitätshistorie (letzte Änderungen)
- Dokumente des Kunden anzeigen
- Projekte des Kunden listen
Priorität: MUST
Story Points: 3
```
#### US-104: Als User möchte ich einen Ansprechpartner hinzufügen
```
Job: Kontaktpersonen zu einer Firma erfassen
Akzeptanzkriterien:
- Name, Position, E-Mail, Telefon
- Als "Hauptansprechpartner" markieren
- Mehrere Kontakte pro Firma
- Schnell-Anruf/-E-Mail Buttons
Priorität: MUST
Story Points: 3
```
#### US-105: Als Manager möchte ich Kunden exportieren
```
Job: Kundenliste für externe Nutzung exportieren
Akzeptanzkriterien:
- CSV-Export
- Excel-Export
- Auswahl: Alle oder gefilterte Liste
- Datenschutz-konform (nur notwendige Daten)
Priorität: SHOULD
Story Points: 3
```
---
### 📁 Projektmanagement
#### US-201: Als User möchte ich ein neues Projekt anlegen
```
Job: Ein Projekt für einen Kunden starten
Akzeptanzkriterien:
- Projektname, Beschreibung
- Kunde auswählen (oder neu anlegen)
- Zeitraum: Start- und Enddatum
- Budget (optional)
- Status: Neu, Aktiv, Abgeschlossen, etc.
- Priorität: Niedrig, Mittel, Hoch, Dringend
Priorität: MUST
Story Points: 5
```
#### US-202: Als User möchte ich Projektmitglieder zuweisen
```
Job: Team-Mitglieder einem Projekt zuordnen
Akzeptanzkriterien:
- Benutzer aus Liste auswählen
- Rolle festlegen: Leiter, Mitglied, Beobachter
- Mitglieder sehen Projekt in ihrer Liste
- Benachrichtigung an neue Mitglieder
Priorität: MUST
Story Points: 3
```
#### US-203: Als User möchte ich den Projektstatus ändern
```
Job: Fortschritt des Projekts dokumentieren
Akzeptanzkriterien:
- Status: Neu → Aktiv → Abgeschlossen
- Status-Änderung mit Kommentar
- Historie aller Status-Änderungen
- Automatische Benachrichtigung an Kunden (optional)
Priorität: MUST
Story Points: 3
```
#### US-204: Als Manager möchte ich alle Projekte sehen
```
Job: Überblick über alle laufenden Projekte
Akzeptanzkriterien:
- Dashboard mit KPIs
- Anzahl Projekte pro Status
- Umsatz pro Projekt (falls Budget gesetzt)
- Filter: Meine Projekte, Alle, Nach Kunde
Priorität: SHOULD
Story Points: 5
```
---
### 📊 Dashboard
#### US-301: Als User möchte ich ein Dashboard sehen
```
Job: Schnellen Überblick über meine Arbeit
Akzeptanzkriterien:
- Meine offenen Projekte
- Meine Aufgaben (später)
- Ungelesene E-Mails (später)
- Aktuelle Aktivitäten
Priorität: MUST
Story Points: 5
```
#### US-302: Als Manager möchte ich Team-Statistiken sehen
```
Job: Team-Performance überwachen
Akzeptanzkriterien:
- Projekte pro Mitarbeiter
- Aktivitäts-Log
- Response-Zeiten (später)
Priorität: SHOULD
Story Points: 5
```
---
## Phase 2: Dokumentenverwaltung
#### US-401: Als User möchte ich Dokumente hochladen
```
Job: Dateien zu einem Projekt speichern
Akzeptanzkriterien:
- Drag & Drop Upload
- Mehrere Dateien gleichzeitig
- Fortschrittsanzeige
- Unterstützte Formate: PDF, Office, Bilder
- Max. 50MB pro Datei
Priorität: MUST
Story Points: 5
```
#### US-402: Als User möchte ich Dokumente herunterladen
```
Job: Gespeicherte Dateien abrufen
Akzeptanzkriterien:
- Einzelner Download
- Mehrfach-Auswahl (ZIP)
- Vorschau für PDF/Bilder
- Download-Tracking
Priorität: MUST
Story Points: 3
```
#### US-403: Als User möchte ich Dokumente versionieren
```
Job: Aktualisierte Dateien hochladen
Akzeptanzkriterien:
- Neue Version hochladen
- Alte Versionen anzeigen
- Auf alte Version zurücksetzen
- Versionsnummer automatisch erhöhen
Priorität: SHOULD
Story Points: 5
```
---
## Phase 3: Aufgabenmanagement
#### US-501: Als User möchte ich Aufgaben erstellen
```
Job: To-Dos zu einem Projekt hinzufügen
Akzeptanzkriterien:
- Titel, Beschreibung
- Fälligkeitsdatum
- Priorität
- Zuständigen zuweisen
- Projekt zuordnen
Priorität: MUST
Story Points: 5
```
#### US-502: Als User möchte ich Aufgaben als erledigt markieren
```
Job: Fortschritt dokumentieren
Akzeptanzkriterien:
- Checkbox für Erledigt
- Erledigungsdatum
- Wer hat erledigt?
- Kommentar zur Erledigung
Priorität: MUST
Story Points: 3
```
#### US-503: Als User möchte ich ein Kanban-Board sehen
```
Job: Aufgaben visuell organisieren
Akzeptanzkriterien:
- Spalten: Offen, In Arbeit, Erledigt
- Drag & Drop zwischen Spalten
- Filter nach Zuständigem
- Farbcodierung nach Priorität
Priorität: SHOULD
Story Points: 8
```
---
## Phase 4: E-Mail-Integration
#### US-601: Als Admin möchte ich ein IMAP-Postfach verbinden
```
Job: E-Mails automatisch importieren
Akzeptanzkriterien:
- IMAP-Server, Port, SSL
- Benutzername, Passwort
- Test-Verbindung
- Sync-Intervall (z.B. alle 15 Min)
Priorität: MUST
Story Points: 8
```
#### US-602: Als User möchte ich E-Mails sehen
```
Job: Importierte E-Mails im CRM ansehen
Akzeptanzkriterien:
- Absender, Betreff, Datum
- HTML- und Text-Ansicht
- Anhänge anzeigen/downloaden
- Als gelesen/ungelesen markieren
Priorität: MUST
Story Points: 5
```
#### US-603: Als User möchte ich E-Mails zuordnen
```
Job: E-Mails Kunden/Projekten zuweisen
Akzeptanzkriterien:
- Manuelle Zuordnung zu Projekt
- Zuordnung zu Kunde
- Automatische Vorschläge (Absender)
- Mehrere E-Mails gleichzeitig zuordnen
Priorität: MUST
Story Points: 5
```
---
## Phase 5: Erweiterungen
#### US-701: Als User möchte ich Google Calendar verbinden
```
Job: Termine synchronisieren
Akzeptanzkriterien:
- OAuth-Login mit Google
- Zwei-Wege-Sync
- Projekt-Termine als Calendar-Events
- Aufgaben-Fristen als Erinnerungen
Priorität: COULD
Story Points: 8
```
#### US-702: Als Manager möchte ich Berichte exportieren
```
Job: Projektberichte erstellen
Akzeptanzkriterien:
- PDF-Export
- Projekt-Zusammenfassung
- Zeitraum auswählen
- Logo/Branding
Priorität: COULD
Story Points: 5
```
#### US-703: Als User möchte ich SeaDrive synchronisieren
```
Job: Dokumente mit Seafile syncen
Akzeptanzkriterien:
- SeaDrive-Account verbinden
- Ausgewählte Ordner syncen
- Konflikt-Resolution
- Offline-Zugriff
Priorität: COULD
Story Points: 13
```
---
## Übersicht
| Phase | Stories | SP | MUST | SHOULD | COULD |
|-------|---------|----|------|--------|-------|
| 1 | 15 | 47 | 11 | 4 | 0 |
| 2 | 3 | 13 | 2 | 1 | 0 |
| 3 | 3 | 16 | 2 | 1 | 0 |
| 4 | 3 | 18 | 3 | 0 | 0 |
| 5 | 3 | 26 | 0 | 0 | 3 |
| **Gesamt** | **27** | **120** | **18** | **6** | **3** |
**Velocity-Schätzung:** 20 SP/Woche
**Gesamt-Dauer:** ~6 Wochen (Nur MUST) / ~9 Wochen (Alles)
---
**Ende User Stories**