breakpilot-pwa/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

{
  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

{
  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

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

Version (Policy Document Meta & Version Meta)

// 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

{
  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

{
  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

{
  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

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

Vendor Meta

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

Vendor Language

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

Sub Service

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

Global Cookie Metadata

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

Global Cookie Language Data

{
  id: number (PK)
  createdAt: timestamp
  updatedAt: timestamp
  globalCookieMetaId: number (FK -> globalCookieMetadata.id, CASCADE)
  language: string
  title: string
  description: text
  file: text (nullable)
}

Project Keys

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

Admin Projects (Junction Table)

{
  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

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

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

Datenbank-Setup

# 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

# Development
npm run start:dev

# Local (mit Watch)
npm run start:local

# Production
npm run start:prod

Frontend starten

# Development Server
npm run start
# oder
ng serve

# Build
npm run build

# Mit PM2
npm run start:pm2

Tests

# 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