breakpilot-pwa/admin-v2/POLICY_VAULT_OVERVIEW.md

# Policy Vault - Projekt-Dokumentation

## Projektübersicht

**Policy Vault** ist eine vollständige Web-Anwendung zur Verwaltung von Datenschutzrichtlinien, Cookie-Einwilligungen und Nutzerzustimmungen für verschiedene Projekte und Plattformen. Das System ermöglicht es Administratoren, Datenschutzdokumente zu erstellen, zu verwalten und zu versionieren, sowie Nutzereinwilligungen zu verfolgen und Cookie-Präferenzen zu speichern.

## Zweck und Anwendungsbereich

Das Policy Vault System dient als zentrale Plattform für:
- **Verwaltung von Datenschutzrichtlinien** (Privacy Policies, Terms of Service, etc.)
- **Cookie-Consent-Management** mit Kategorisierung und Vendor-Verwaltung
- **Versionskontrolle** für Richtliniendokumente
- **Multi-Projekt-Verwaltung** mit rollenbasiertem Zugriff
- **Nutzereinwilligungs-Tracking** über verschiedene Plattformen hinweg
- **Mehrsprachige Unterstützung** für globale Anwendungen

---

## Technologie-Stack

### Backend
- **Framework**: NestJS (Node.js/TypeScript)
- **Datenbank**: PostgreSQL
- **ORM**: Drizzle ORM
- **Authentifizierung**: JWT (JSON Web Tokens) mit Access/Refresh Token
- **API-Dokumentation**: Swagger/OpenAPI
- **Validierung**: class-validator, class-transformer
- **Security**:
  - Encryption-based authentication
  - Rate limiting (Throttler)
  - Role-based access control (RBAC)
  - bcrypt für Password-Hashing
- **Logging**: Winston mit Daily Rotate File
- **Job Scheduling**: NestJS Schedule
- **E-Mail**: Nodemailer
- **OTP-Generierung**: otp-generator

### Frontend
- **Framework**: Angular 18
- **UI**:
  - TailwindCSS
  - Custom SCSS
- **Rich Text Editor**: CKEditor 5
  - Alignment, Block Quote, Code Block
  - Font styling, Image support
  - List und Table support
- **State Management**: RxJS
- **Security**: DOMPurify für HTML-Sanitization
- **Multi-Select**: ng-multiselect-dropdown
- **Process Manager**: PM2

---

## Hauptfunktionen und Features

### 1. Administratoren-Verwaltung
- **Super Admin und Admin Rollen**
  - Super Admin (Role 1): Vollzugriff auf alle Funktionen
  - Admin (Role 2): Eingeschränkter Zugriff auf zugewiesene Projekte
- **Authentifizierung**
  - Login mit E-Mail und Passwort
  - JWT-basierte Sessions (Access + Refresh Token)
  - OTP-basierte Passwort-Wiederherstellung
  - Account-Lock-Mechanismus bei mehrfachen Fehlversuchen
- **Benutzerverwaltung**
  - Admin-Erstellung durch Super Admin
  - Projekt-Zuweisungen für Admins
  - Rollen-Modifikation (Promote/Demote)
  - Soft-Delete (isDeleted Flag)

### 2. Projekt-Management
- **Projektverwaltung**
  - Erstellung und Verwaltung von Projekten
  - Projekt-spezifische Konfiguration (Theme-Farben, Icons, Logos)
  - Mehrsprachige Unterstützung (Language Configuration)
  - Projekt-Keys für sichere API-Zugriffe
  - Soft-Delete und Blocking von Projekten
- **Projekt-Zugriffskontrolle**
  - Zuweisung von Admins zu spezifischen Projekten
  - Project-Admin-Beziehungen

### 3. Policy Document Management
- **Dokumentenverwaltung**
  - Erstellung von Datenschutzdokumenten (Privacy Policies, ToS, etc.)
  - Projekt-spezifische Dokumente
  - Beschreibung und Metadaten
- **Versionierung**
  - Multiple Versionen pro Dokument
  - Version-Metadaten mit Inhalt
  - Publish/Draft-Status
  - Versionsnummern-Tracking

### 4. Cookie-Consent-Management
- **Cookie-Kategorien**
  - Kategorien-Metadaten (z.B. Notwendig, Marketing, Analytics)
  - Plattform-spezifische Kategorien (Web, Mobile, etc.)
  - Versionierung der Kategorien
  - Pflicht- und optionale Kategorien
  - Mehrsprachige Kategorie-Beschreibungen
- **Vendor-Management**
  - Verwaltung von Drittanbieter-Services
  - Vendor-Metadaten und -Beschreibungen
  - Zuordnung zu Kategorien
  - Sub-Services für Vendors
  - Mehrsprachige Vendor-Informationen
- **Globale Cookie-Einstellungen**
  - Projekt-weite Cookie-Texte und -Beschreibungen
  - Mehrsprachige globale Inhalte
  - Datei-Upload-Unterstützung

### 5. User Consent Tracking
- **Policy Document Consent**
  - Tracking von Nutzereinwilligungen für Richtlinien-Versionen
  - Username-basiertes Tracking
  - Status (Akzeptiert/Abgelehnt)
  - Timestamp-Tracking
- **Cookie Consent**
  - Granulare Cookie-Einwilligungen pro Kategorie
  - Vendor-spezifische Einwilligungen
  - Versions-Tracking
  - Username und Projekt-basiert
- **Verschlüsselte API-Zugriffe**
  - Token-basierte Authentifizierung für Mobile/Web
  - Encryption-based authentication für externe Zugriffe

### 6. Mehrsprachige Unterstützung
- **Language Management**
  - Dynamische Sprachen-Konfiguration pro Projekt
  - Mehrsprachige Inhalte für:
    - Kategorien-Beschreibungen
    - Vendor-Informationen
    - Globale Cookie-Texte
    - Sub-Service-Beschreibungen

---

## API-Struktur und Endpoints

### Admin-Endpoints (`/admins`)
```
POST   /admins/create-admin                    - Admin erstellen (Super Admin only)
POST   /admins/create-super-admin              - Super Admin erstellen (Super Admin only)
POST   /admins/create-root-user-super-admin    - Root Super Admin erstellen (Secret-based)
POST   /admins/login                           - Admin Login
GET    /admins/get-access-token                - Neuen Access Token abrufen
POST   /admins/generate-otp                    - OTP für Passwort-Reset generieren
POST   /admins/validate-otp                    - OTP validieren
POST   /admins/change-password                 - Passwort ändern (mit OTP)
PUT    /admins/update-password                 - Passwort aktualisieren (eingeloggt)
PUT    /admins/forgot-password                 - Passwort vergessen
PUT    /admins/make-super-admin                - Admin zu Super Admin befördern
PUT    /admins/remove-super-admin              - Super Admin zu Admin zurückstufen
PUT    /admins/make-project-admin              - Projekt-Zugriff gewähren
DELETE /admins/remove-project-admin            - Projekt-Zugriff entfernen
GET    /admins/findAll?role=                   - Alle Admins abrufen (gefiltert nach Rolle)
GET    /admins/findAll-super-admins            - Alle Super Admins abrufen
GET    /admins/findOne?id=                     - Einzelnen Admin abrufen
PUT    /admins/update                          - Admin-Details aktualisieren
DELETE /admins/delete-admin?id=               - Admin löschen (Soft-Delete)
```

### Project-Endpoints (`/project`)
```
POST   /project/create                         - Projekt erstellen (Super Admin only)
PUT    /project/v2/updateProjectKeys           - Projekt-Keys aktualisieren
GET    /project/findAll                        - Alle Projekte abrufen (mit Pagination)
GET    /project/findAllByUser                  - Projekte eines bestimmten Users
GET    /project/findOne?id=                    - Einzelnes Projekt abrufen
PUT    /project/update                         - Projekt aktualisieren
DELETE /project/delete?id=                     - Projekt löschen
```

### Policy Document-Endpoints (`/policydocument`)
```
POST   /policydocument/create                  - Policy Document erstellen
GET    /policydocument/findAll                 - Alle Policy Documents abrufen
GET    /policydocument/findOne?id=             - Einzelnes Policy Document
GET    /policydocument/findPolicyDocs?projectId= - Documents für ein Projekt
PUT    /policydocument/update                  - Policy Document aktualisieren
DELETE /policydocument/delete?id=              - Policy Document löschen
```

### Version-Endpoints (`/version`)
```
POST   /version/create                         - Version erstellen
GET    /version/findAll                        - Alle Versionen abrufen
GET    /version/findOne?id=                    - Einzelne Version abrufen
GET    /version/findVersions?policyDocId=      - Versionen für ein Policy Document
PUT    /version/update                         - Version aktualisieren
DELETE /version/delete?id=                     - Version löschen
```

### User Consent-Endpoints (`/consent`)
```
POST   /consent/v2/create                      - User Consent erstellen (Encrypted)
GET    /consent/v2/GetConsent                  - Consent abrufen (Encrypted)
GET    /consent/v2/GetConsentFileContent       - Consent mit Dateiinhalt (Encrypted)
GET    /consent/v2/latestAcceptedConsent       - Letzte akzeptierte Consent
DELETE /consent/v2/delete                      - Consent löschen (Encrypted)
```

### Cookie Consent-Endpoints (`/cookieconsent`)
```
POST   /cookieconsent/v2/create                - Cookie Consent erstellen (Encrypted)
GET    /cookieconsent/v2/get                   - Cookie Kategorien abrufen (Encrypted)
GET    /cookieconsent/v2/getFileContent        - Cookie Daten mit Dateiinhalt (Encrypted)
DELETE /cookieconsent/v2/delete                - Cookie Consent löschen (Encrypted)
```

### Cookie-Endpoints (`/cookies`)
```
POST   /cookies/createCategory                 - Cookie-Kategorie erstellen
POST   /cookies/createVendor                   - Vendor erstellen
POST   /cookies/createGlobalCookie             - Globale Cookie-Einstellung erstellen
GET    /cookies/getCategories?projectId=       - Kategorien für Projekt abrufen
GET    /cookies/getVendors?projectId=          - Vendors für Projekt abrufen
GET    /cookies/getGlobalCookie?projectId=     - Globale Cookie-Settings
PUT    /cookies/updateCategory                 - Kategorie aktualisieren
PUT    /cookies/updateVendor                   - Vendor aktualisieren
PUT    /cookies/updateGlobalCookie             - Globale Settings aktualisieren
DELETE /cookies/deleteCategory?id=             - Kategorie löschen
DELETE /cookies/deleteVendor?id=               - Vendor löschen
DELETE /cookies/deleteGlobalCookie?id=         - Globale Settings löschen
```

### Health Check-Endpoint (`/db-health-check`)
```
GET    /db-health-check                        - Datenbank-Status prüfen
```

---

## Datenmodelle

### Admin
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  employeeCode: string (nullable)
  firstName: string (max 60)
  lastName: string (max 50)
  officialMail: string (unique, max 100)
  role: number (1 = Super Admin, 2 = Admin)
  passwordHash: string
  salt: string (nullable)
  accessToken: text (nullable)
  refreshToken: text (nullable)
  accLockCount: number (default 0)
  accLockTime: number (default 0)
  isBlocked: boolean (default false)
  isDeleted: boolean (default false)
  otp: string (nullable)
}
```

### Project
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  name: string (unique)
  description: string
  imageURL: text (nullable)
  iconURL: text (nullable)
  isBlocked: boolean (default false)
  isDeleted: boolean (default false)
  themeColor: string
  textColor: string
  languages: json (nullable) // Array von Sprach-Codes
}
```

### Policy Document
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  name: string
  description: string (nullable)
  projectId: number (FK -> project.id, CASCADE)
}
```

### Version (Policy Document Meta & Version Meta)
```typescript
// Policy Document Meta
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  policyDocumentId: number (FK)
  version: string
  isPublish: boolean
}

// Version Meta (Sprachspezifischer Inhalt)
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  policyDocMetaId: number (FK)
  language: string
  content: text
  file: text (nullable)
}
```

### User Consent
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  username: string
  status: boolean
  projectId: number (FK -> project.id, CASCADE)
  versionMetaId: number (FK -> versionMeta.id, CASCADE)
}
```

### Cookie Consent
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  username: string
  categoryId: number[] (Array)
  vendors: number[] (Array)
  projectId: number (FK -> project.id, CASCADE)
  version: string
}
```

### Categories Metadata
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  projectId: number (FK -> project.id, CASCADE)
  platform: string
  version: string
  isPublish: boolean (default false)
  metaName: string
  isMandatory: boolean (default false)
}
```

### Categories Language Data
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  categoryMetaId: number (FK -> categoriesMetadata.id, CASCADE)
  language: string
  title: string
  description: text
}
```

### Vendor Meta
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  categoryId: number (FK -> categoriesMetadata.id, CASCADE)
  vendorName: string
}
```

### Vendor Language
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  vendorMetaId: number (FK -> vendorMeta.id, CASCADE)
  language: string
  description: text
}
```

### Sub Service
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  vendorMetaId: number (FK -> vendorMeta.id, CASCADE)
  serviceName: string
}
```

### Global Cookie Metadata
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  projectId: number (FK -> project.id, CASCADE)
  version: string
  isPublish: boolean (default false)
}
```

### Global Cookie Language Data
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  globalCookieMetaId: number (FK -> globalCookieMetadata.id, CASCADE)
  language: string
  title: string
  description: text
  file: text (nullable)
}
```

### Project Keys
```typescript
{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  projectId: number (FK -> project.id, CASCADE)
  publicKey: text
  privateKey: text
}
```

### Admin Projects (Junction Table)
```typescript
{
  id: number (PK)
  adminId: number (FK -> admin.id, CASCADE)
  projectId: number (FK -> project.id, CASCADE)
}
```

---

## Architektur-Übersicht

### Backend-Architektur

```
┌─────────────────────────────────────────────────────────────┐
│                      NestJS Backend                         │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │   Guards     │  │ Middlewares  │  │ Interceptors │      │
│  ├──────────────┤  ├──────────────┤  ├──────────────┤      │
│  │ - AuthGuard  │  │ - Token      │  │ - Serialize  │      │
│  │ - RolesGuard │  │ - Decrypt    │  │ - Logging    │      │
│  │ - Throttler  │  │ - Headers    │  │              │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
│                                                               │
│  ┌───────────────────────────────────────────────────┐      │
│  │              API Modules                          │      │
│  ├───────────────────────────────────────────────────┤      │
│  │ - Admins (Authentication, Authorization)          │      │
│  │ - Projects (Multi-tenant Management)              │      │
│  │ - Policy Documents (Document Management)          │      │
│  │ - Versions (Versioning System)                    │      │
│  │ - User Consent (Consent Tracking)                 │      │
│  │ - Cookies (Cookie Categories & Vendors)           │      │
│  │ - Cookie Consent (Cookie Consent Tracking)        │      │
│  │ - DB Health Check (System Monitoring)             │      │
│  └───────────────────────────────────────────────────┘      │
│                                                               │
│  ┌───────────────────────────────────────────────────┐      │
│  │           Drizzle ORM Layer                       │      │
│  ├───────────────────────────────────────────────────┤      │
│  │ - Schema Definitions                              │      │
│  │ - Relations                                        │      │
│  │ - Database Connection Pool                        │      │
│  └───────────────────────────────────────────────────┘      │
│                          │                                    │
└──────────────────────────┼────────────────────────────────────┘
                           │
                           ▼
                  ┌─────────────────┐
                  │   PostgreSQL    │
                  │    Database     │
                  └─────────────────┘
```

### Frontend-Architektur

```
┌─────────────────────────────────────────────────────────────┐
│                    Angular Frontend                         │
├─────────────────────────────────────────────────────────────┤
│                                                               │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐      │
│  │   Guards     │  │ Interceptors │  │  Services    │      │
│  ├──────────────┤  ├──────────────┤  ├──────────────┤      │
│  │ - AuthGuard  │  │ - HTTP       │  │ - Auth       │      │
│  │              │  │ - Error      │  │ - REST API   │      │
│  │              │  │              │  │ - Session    │      │
│  │              │  │              │  │ - Security   │      │
│  └──────────────┘  └──────────────┘  └──────────────┘      │
│                                                               │
│  ┌───────────────────────────────────────────────────┐      │
│  │            Feature Modules                        │      │
│  ├───────────────────────────────────────────────────┤      │
│  │ ┌─────────────────────────────────────────┐       │      │
│  │ │ Auth Module                             │       │      │
│  │ │ - Login Component                       │       │      │
│  │ └─────────────────────────────────────────┘       │      │
│  │                                                     │      │
│  │ ┌─────────────────────────────────────────┐       │      │
│  │ │ Project Dashboard                       │       │      │
│  │ │ - Project List                          │       │      │
│  │ │ - Project Creation                      │       │      │
│  │ │ - Project Settings                      │       │      │
│  │ └─────────────────────────────────────────┘       │      │
│  │                                                     │      │
│  │ ┌─────────────────────────────────────────┐       │      │
│  │ │ Individual Project Dashboard            │       │      │
│  │ │ - Agreements (Policy Documents)         │       │      │
│  │ │ - Cookie Consent Management             │       │      │
│  │ │ - FAQ Management                        │       │      │
│  │ │ - Licenses Management                   │       │      │
│  │ │ - User Management                       │       │      │
│  │ │ - Project Settings                      │       │      │
│  │ └─────────────────────────────────────────┘       │      │
│  │                                                     │      │
│  │ ┌─────────────────────────────────────────┐       │      │
│  │ │ Shared Components                       │       │      │
│  │ │ - Settings                              │       │      │
│  │ │ - Common UI Elements                    │       │      │
│  │ └─────────────────────────────────────────┘       │      │
│  └───────────────────────────────────────────────────┘      │
│                                                               │
└─────────────────────────────────────────────────────────────┘
                           │
                           │ HTTPS/REST API
                           ▼
                  ┌─────────────────┐
                  │  NestJS Backend │
                  └─────────────────┘
```

### Datenbankbeziehungen

```
┌──────────┐         ┌─────────────────┐         ┌─────────────┐
│  Admin   │◄───────►│ AdminProjects   │◄───────►│   Project   │
└──────────┘         └─────────────────┘         └─────────────┘
                                                          │
                                                          │ 1:N
                     ┌────────────────────────────────────┤
                     │                                    │
                     ▼                                    ▼
         ┌──────────────────────┐         ┌──────────────────────────┐
         │ Policy Document      │         │ Categories Metadata      │
         └──────────────────────┘         └──────────────────────────┘
                     │                                    │
                     │ 1:N                                │ 1:N
                     ▼                                    ▼
         ┌──────────────────────┐         ┌──────────────────────────┐
         │ Policy Document Meta │         │ Categories Language Data │
         └──────────────────────┘         └──────────────────────────┘
                     │                                    │
                     │ 1:N                                │ 1:N
                     ▼                                    ▼
         ┌──────────────────────┐         ┌──────────────────────────┐
         │ Version Meta         │         │ Vendor Meta              │
         └──────────────────────┘         └──────────────────────────┘
                     │                                    │
                     │ 1:N                                │ 1:N
                     ▼                                    ├──────────┐
         ┌──────────────────────┐                        ▼          ▼
         │ User Consent         │         ┌─────────────────┐  ┌────────────┐
         └──────────────────────┘         │ Vendor Language │  │Sub Service │
                                          └─────────────────┘  └────────────┘
┌──────────────────────┐
│ Cookie Consent       │◄─── Project
└──────────────────────┘

┌─────────────────────────┐
│ Global Cookie Metadata  │◄─── Project
└─────────────────────────┘
                │
                │ 1:N
                ▼
┌─────────────────────────────┐
│ Global Cookie Language Data │
└─────────────────────────────────┘

┌──────────────────┐
│ Project Keys     │◄─── Project
└──────────────────┘
```

### Sicherheitsarchitektur

#### Authentifizierung & Autorisierung
1. **JWT-basierte Authentifizierung**
   - Access Token (kurzlebig)
   - Refresh Token (langlebig)
   - Token-Refresh-Mechanismus

2. **Rollenbasierte Zugriffskontrolle (RBAC)**
   - Super Admin (Role 1): Vollzugriff
   - Admin (Role 2): Projektbezogener Zugriff
   - Guard-basierte Absicherung auf Controller-Ebene

3. **Encryption-based Authentication**
   - Für externe/mobile Zugriffe
   - Token-basierte Verschlüsselung
   - User + Project ID Validierung

#### Security Features
- **Rate Limiting**: Throttler mit konfigurierbaren Limits
- **Password Security**: bcrypt Hashing mit Salt
- **Account Lock**: Nach mehrfachen Fehlversuchen
- **OTP-basierte Passwort-Wiederherstellung**
- **Input Validation**: class-validator auf allen DTOs
- **HTML Sanitization**: DOMPurify im Frontend
- **CORS Configuration**: Custom Headers Middleware
- **Soft Delete**: Keine permanente Löschung von Daten

---

## Deployment und Konfiguration

### Backend Environment Variables
```env
DATABASE_URL=postgresql://username:password@host:port/database
NODE_ENV=development|test|production|local|demo
PORT=3000
JWT_SECRET=your_jwt_secret
JWT_REFRESH_SECRET=your_refresh_secret
ROOT_SECRET=your_root_secret
ENCRYPTION_KEY=your_encryption_key
SMTP_HOST=smtp.example.com
SMTP_PORT=587
SMTP_USER=your_email
SMTP_PASSWORD=your_password
```

### Frontend Environment
```typescript
{
  production: false,
  BASE_URL: "https://api.example.com/api/",
  TITLE: "Policy Vault - Environment"
}
```

### Datenbank-Setup
```bash
# Migrationen ausführen
npm run migration:up

# Migrationen zurückrollen
npm run migration:down

# Schema generieren
npx drizzle-kit push
```

---

## API-Sicherheit

### Token-basierte Authentifizierung
- Alle geschützten Endpoints erfordern einen gültigen JWT-Token im Authorization-Header
- Format: `Authorization: Bearer <access_token>`

### Encryption-based Endpoints
Für mobile/externe Zugriffe (Consent Tracking):
- Header: `secret` oder `mobiletoken`
- Format: Verschlüsselter String mit `userId_projectId`
- Automatische Validierung durch DecryptMiddleware

### Rate Limiting
- Standard: 10 Requests pro Minute
- OTP/Login: 3 Requests pro Minute
- Konfigurierbar über ThrottlerModule

---

## Besondere Features

### 1. Versionierung
- Komplettes Versions-Management für Policy Documents
- Mehrsprachige Versionen mit separaten Inhalten
- Publish/Draft Status
- Historische Versionsverfolgung

### 2. Mehrsprachigkeit
- Zentrale Sprach-Konfiguration pro Projekt
- Separate Language-Data Tabellen für alle Inhaltstypen
- Support für unbegrenzte Sprachen

### 3. Cookie-Consent-System
- Granulare Kontrolle über Cookie-Kategorien
- Vendor-Management mit Sub-Services
- Plattform-spezifische Kategorien (Web, Mobile, etc.)
- Versions-Tracking für Compliance

### 4. Rich Content Editing
- CKEditor 5 Integration
- Support für komplexe Formatierungen
- Bild-Upload und -Verwaltung
- Code-Block-Unterstützung

### 5. Logging & Monitoring
- Winston-basiertes Logging
- Daily Rotate Files
- Structured Logging
- Fehler-Tracking
- Datenbank-Health-Checks

### 6. Soft Delete Pattern
- Keine permanente Datenlöschung
- `isDeleted` Flags auf allen Haupt-Entitäten
- Möglichkeit zur Wiederherstellung
- Audit Trail Erhaltung

---

## Entwicklung

### Backend starten
```bash
# Development
npm run start:dev

# Local (mit Watch)
npm run start:local

# Production
npm run start:prod
```

### Frontend starten
```bash
# Development Server
npm run start
# oder
ng serve

# Build
npm run build

# Mit PM2
npm run start:pm2
```

### Tests
```bash
# Backend Tests
npm run test
npm run test:e2e
npm run test:cov

# Frontend Tests
npm run test
```

---

## Zusammenfassung

Policy Vault ist eine umfassende Enterprise-Lösung für die Verwaltung von Datenschutzrichtlinien und Cookie-Einwilligungen. Das System bietet:

- **Multi-Tenant-Architektur** mit Projekt-basierter Trennung
- **Robuste Authentifizierung** mit JWT und rollenbasierter Zugriffskontrolle
- **Vollständiges Versions-Management** für Compliance-Tracking
- **Granulare Cookie-Consent-Verwaltung** mit Vendor-Support
- **Mehrsprachige Unterstützung** für globale Anwendungen
- **Moderne Tech-Stack** mit NestJS, Angular und PostgreSQL
- **Enterprise-Grade Security** mit Encryption, Rate Limiting und Audit Trails
- **Skalierbare Architektur** mit klarer Trennung von Concerns

Das System eignet sich ideal für Unternehmen, die:
- Multiple Projekte/Produkte mit unterschiedlichen Datenschutzrichtlinien verwalten
- GDPR/DSGVO-Compliance sicherstellen müssen
- Granulare Cookie-Einwilligungen tracken wollen
- Mehrsprachige Anwendungen betreiben
- Eine zentrale Policy-Management-Plattform benötigen