# Benutzer- und Rechteverwaltung

## Übersicht

myCRM verwendet ein **modulares Rechtesystem** mit granularen Berechtigungen pro Modul.

## Architektur

### Entities

1. **User** (`users`) - Benutzer mit Authentifizierung
   - Email (Login)
   - Vorname, Nachname
   - Password (gehashed)
   - Aktiv-Status
   - Multiple Rollen (ManyToMany)

2. **Role** (`roles`) - Rollen mit konfigurierbaren Berechtigungen
   - Name (z.B. "Administrator", "Vertriebsmitarbeiter")
   - Beschreibung
   - System-Rolle Flag (nicht löschbar)
   - Berechtigungen pro Modul

3. **Module** (`modules`) - CRM-Module
   - Name, Code (eindeutig)
   - Icon (PrimeIcons)
   - Sortierung
   - Aktiv-Status

4. **RolePermission** (`role_permissions`) - Verknüpfung Rolle ↔ Modul
   - Pro Modul definierbare Aktionen:
     - `canView` - Anzeigen
     - `canCreate` - Erstellen
     - `canEdit` - Bearbeiten
     - `canDelete` - Löschen
     - `canExport` - Exportieren
     - `canManage` - Verwalten (Admin-Rechte)

## Standard-Module

Nach dem Setup via Fixtures verfügbar:

| Modul | Code | Icon | Beschreibung |
|-------|------|------|--------------|
| Dashboard | `dashboard` | pi-chart-line | Übersicht und KPIs |
| Kontakte | `contacts` | pi-users | Kontaktverwaltung |
| Unternehmen | `companies` | pi-building | Firmendatenbank |
| Deals | `deals` | pi-dollar | Sales-Pipeline |
| Aktivitäten | `activities` | pi-calendar | Interaktions-Historie |
| Berichte | `reports` | pi-chart-bar | Analytics |
| Einstellungen | `settings` | pi-cog | Systemeinstellungen |

## Standard-Rollen

### Administrator
- **Vollzugriff** auf alle Module
- Alle Aktionen erlaubt (View, Create, Edit, Delete, Export, Manage)
- System-Rolle (nicht löschbar)

### Vertriebsmitarbeiter
- Zugriff auf: Dashboard, Kontakte, Unternehmen, Deals, Aktivitäten
- Kann erstellen, bearbeiten, exportieren
- **Kein** Lösch- und Manage-Recht

### Betrachter
- **Nur Leserechte** auf die meisten Module
- Keine Create/Edit/Delete/Export Rechte

## Test-Benutzer

Nach `doctrine:fixtures:load` verfügbar:

| Email | Passwort | Rolle | Name |
|-------|----------|-------|------|
| admin@mycrm.local | admin123 | Administrator | Admin User |
| sales@mycrm.local | sales123 | Vertriebsmitarbeiter | Max Mustermann |

⚠️ **Wichtig:** Diese Passwörter sind nur für Development! In Production bitte ändern.

## Usage in Code

### Berechtigung prüfen (in User-Entity)

```php
// In Controller oder Service
$user = $this->getUser();

if ($user->hasModulePermission('contacts', 'create')) {
    // User darf Kontakte erstellen
}

if ($user->hasModulePermission('deals', 'delete')) {
    // User darf Deals löschen
}
```

### Mögliche Aktionen

- `view` - Anzeigen
- `create` - Erstellen
- `edit` - Bearbeiten
- `delete` - Löschen
- `export` - Exportieren
- `manage` - Verwalten

### In Twig Templates

```twig
{% if app.user.hasModulePermission('contacts', 'create') %}
    <button>Neuer Kontakt</button>
{% endif %}
```

### Mit Symfony Voters (empfohlen)

```php
// In Controller
$this->denyAccessUnlessGranted('MODULE_VIEW', 'contacts');
$this->denyAccessUnlessGranted('MODULE_CREATE', 'contacts');
```

## Neue Rolle erstellen

```php
use App\Entity\Role;
use App\Entity\RolePermission;

$role = new Role();
$role->setName('Kundensupport');
$role->setDescription('Support-Team mit eingeschränkten Rechten');
$role->setIsSystem(false);

$entityManager->persist($role);

// Berechtigungen hinzufügen
$contactsModule = $moduleRepository->findByCode('contacts');

$permission = new RolePermission();
$permission->setRole($role);
$permission->setModule($contactsModule);
$permission->setCanView(true);
$permission->setCanEdit(true);
$permission->setCanCreate(false);
$permission->setCanDelete(false);
$permission->setCanExport(false);
$permission->setCanManage(false);

$entityManager->persist($permission);
$entityManager->flush();
```

## Neues Modul hinzufügen

```php
use App\Entity\Module;

$module = new Module();
$module->setName('Tickets');
$module->setCode('tickets');
$module->setDescription('Support-Ticketsystem');
$module->setIcon('pi-ticket');
$module->setSortOrder(70);
$module->setIsActive(true);

$entityManager->persist($module);
$entityManager->flush();

// Dann Berechtigungen für existierende Rollen definieren...
```

## API Platform Integration

Die Entities können über API Platform exponiert werden:

```php
use ApiPlatform\Metadata\ApiResource;

#[ApiResource]
class Role { ... }
```

## Security Best Practices

1. **System-Rollen** (`isSystem = true`) können nicht gelöscht werden
2. **Passwörter** werden mit Symfony Password Hasher gehashed
3. **Inactive Users** (`isActive = false`) können sich nicht einloggen
4. **Symfony Standard Roles** (`ROLE_ADMIN`, `ROLE_USER`) für grundlegende Zugriffskontrolle
5. **Modulare Berechtigungen** für feingranulare Kontrolle

## Datenbank-Schema

```
users
  ├─ id, email, firstName, lastName, password, isActive
  ├─ roles (JSON Array - Symfony Standard Roles)
  └─ createdAt, lastLoginAt

roles
  ├─ id, name, description, isSystem
  └─ createdAt, updatedAt

modules
  └─ id, name, code, description, icon, sortOrder, isActive

role_permissions
  ├─ id, role_id, module_id
  └─ canView, canCreate, canEdit, canDelete, canExport, canManage

user_roles (ManyToMany Join Table)
  └─ user_id, role_id
```

## Next Steps

- [ ] Voter erstellen für `MODULE_*` Permissions
- [ ] API Endpoints für Role Management
- [ ] Vue.js Components für User/Role Administration
- [ ] Audit Log für Berechtigungsänderungen