Tenant-Benutzeroperationen

Tenant-bezogene Benutzerendpunkte verwalten Benutzer innerhalb eines bestimmten Tenants. Auf diese Endpunkte kann entweder mit einem Global API Key oder einem Tenant API Key zugegriffen werden.

Authentifizierung

API Key Typ	Zugriff
Global API Key	Kann auf jeden Tenant zugreifen
Tenant API Key	Kann nur auf den eigenen Tenant zugreifen

---

Benutzer für Tenant auflisten

GET /api/tenant/{tenantId}/user

Ruft Benutzer ab, die einem bestimmten Tenant zugewiesen sind.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
tenantId	GUID	Ja	Die Tenant-ID

Abfrageparameter

Parameter	Typ	Standard	Beschreibung
page	integer	1	Seitenzahl für die Paginierung
pageSize	integer	50	Anzahl der Einträge pro Seite (max: 1000)
includeDisabled	boolean	false	Deaktivierte Benutzer einbeziehen
role	string	null	Nach Rollenname filtern
search	string	null	Suche nach E-Mail oder Anzeigename

Antwort (200 OK)

Gleiche Struktur wie die globale Liste aller Benutzer, jedoch gefiltert auf den angegebenen Tenant.

---

Benutzer in Tenant erstellen

POST /api/tenant/{tenantId}/user

Erstellt einen neuen Benutzer UND weist ihn dem Tenant zu oder weist einen bestehenden Benutzer dem Tenant zu.

Hinweis: Wenn bereits ein Benutzer mit der angegebenen E-Mail existiert, wird dieser dem Tenant zugewiesen, anstatt einen Duplikat zu erstellen.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
tenantId	GUID	Ja	Die Tenant-ID

Anfragekörper

{
  "email": "john.smith@example.com",
  "displayName": "John Smith",
  "firstName": "John",
  "lastName": "Smith",
  "roleName": "Analyst"
}

Anfragedatenfelder

Feld	Typ	Erforderlich	Beschreibung
email	string	Ja	E-Mail-Adresse des Benutzers
displayName	string	Ja	Anzeigename (2-100 Zeichen)
firstName	string	Nein	Vorname (max. 50 Zeichen)
lastName	string	Nein	Nachname (max. 50 Zeichen)
roleName	string	Ja	Rollenname (siehe Rollen & Berechtigungen)

Kapazitätsprüfung

Der Vorgang prüft die Kapazitätsgrenzen des Tenants:

• MaxUsers wird für alle Rollen überprüft
• MaxAnalyst wird für Analyst-Rollen geprüft

Antwort (201 Created)

{
  "userId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "email": "john.smith@example.com",
  "displayName": "John Smith",
  "message": "Benutzer wurde erfolgreich erstellt und dem Tenant zugewiesen"
}

Fehlerantworten

Konflikt (409):

{
  "error": "Benutzer ist bereits diesem Tenant zugewiesen"
}

Kapazitätsüberschreitung (400):

{
  "error": "Benutzer kann nicht hinzugefügt werden: Tenant hat sein maximales Benutzerlimit (100) erreicht",
  "hint": "Erhöhen Sie das Benutzer- oder Analystenlimit des Tenants, um mehr Benutzer hinzuzufügen"
}

---

Benutzer im Tenant abrufen

GET /api/tenant/{tenantId}/user/{userId}

Ruft einen bestimmten Benutzer im Tenant-Kontext ab.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
tenantId	GUID	Ja	Die Tenant-ID
userId	GUID	Ja	Die Benutzer-ID

Antwort (200 OK)

Gibt das Benutzerobjekt zurück, sofern dieser dem Tenant zugewiesen ist.

---

Benutzer per E-Mail im Tenant abrufen

GET /api/tenant/{tenantId}/user/by-email/{email}

Ruft einen Benutzer per E-Mail im Tenant-Kontext ab.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
tenantId	GUID	Ja	Die Tenant-ID
email	string	Ja	E-Mail-Adresse des Benutzers (URL-kodiert)

Antwort (200 OK)

Gibt das Benutzerobjekt zurück, sofern dieser dem Tenant zugewiesen ist.

---

Bestehenden Benutzer Tenant zuweisen

POST /api/tenant/{tenantId}/user/{userId}

Weist einem Tenant einen bestehenden Benutzer zu.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
tenantId	GUID	Ja	Die Tenant-ID
userId	GUID	Ja	Die Benutzer-ID

Anfragekörper (Optional)

{
  "roleName": "Analyst"
}

Antwort (200 OK)

{
  "message": "Benutzer wurde erfolgreich dem Tenant zugewiesen"
}

---

Benutzer im Tenant aktualisieren

PUT /api/tenant/{tenantId}/user/{userId}

Aktualisiert die Eigenschaften eines Benutzers im Tenant-Kontext.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
tenantId	GUID	Ja	Die Tenant-ID
userId	GUID	Ja	Die Benutzer-ID

Anfragekörper

{
  "displayName": "Aktualisierter Name",
  "roleName": "TenantAdmin"
}

Antwort (200 OK)

{
  "message": "Benutzer wurde erfolgreich aktualisiert"
}

---

Benutzer aus Tenant entfernen

DELETE /api/tenant/{tenantId}/user/{userId}

Entfernt die Zuordnung eines Benutzers von einem Tenant. Der Benutzer wird dabei NICHT aus dem System gelöscht.

Pfadparameter

Parameter	Typ	Erforderlich	Beschreibung
tenantId	GUID	Ja	Die Tenant-ID
userId	GUID	Ja	Die Benutzer-ID

Antwort (200 OK)

{
  "message": "Benutzer wurde erfolgreich aus dem Tenant entfernt"
}

Fehlerantworten

Nicht gefunden (404):

{
  "error": "Benutzer ist nicht diesem Tenant zugewiesen"
}

---

Implementierungsbeispiele

cURL

# Benutzer für einen Tenant auflisten (Tenant API Key funktioniert)
curl -X GET "https://your-mindzie-instance.com/api/tenant/12345678-1234-1234-1234-123456789012/user" \
  -H "Authorization: Bearer YOUR_TENANT_API_KEY"

# Benutzer im Tenant suchen
curl -X GET "https://your-mindzie-instance.com/api/tenant/12345678-1234-1234-1234-123456789012/user?search=john" \
  -H "Authorization: Bearer YOUR_TENANT_API_KEY"

# Benutzer im Tenant erstellen (erstellt Benutzer UND weist zu)
curl -X POST "https://your-mindzie-instance.com/api/tenant/12345678-1234-1234-1234-123456789012/user" \
  -H "Authorization: Bearer YOUR_TENANT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "new.user@example.com",
    "displayName": "New User",
    "roleName": "Analyst"
  }'

# Bestehenden Benutzer einem Tenant zuweisen
curl -X POST "https://your-mindzie-instance.com/api/tenant/12345678-1234-1234-1234-123456789012/user/a1b2c3d4-e5f6-7890-abcd-ef1234567890" \
  -H "Authorization: Bearer YOUR_TENANT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"roleName": "Analyst"}'

# Benutzer aus Tenant entfernen
curl -X DELETE "https://your-mindzie-instance.com/api/tenant/12345678-1234-1234-1234-123456789012/user/a1b2c3d4-e5f6-7890-abcd-ef1234567890" \
  -H "Authorization: Bearer YOUR_TENANT_API_KEY"

Python

import requests

BASE_URL = 'https://your-mindzie-instance.com'

class TenantUserManager:
    def __init__(self, api_key, tenant_id):
        """
        Initialisiert mit einem API Key und einer Tenant-ID.
        Funktioniert mit Globalen oder Tenant API Keys.
        """
        self.headers = {
            'Authorization': f'Bearer {api_key}',
            'Content-Type': 'application/json'
        }
        self.tenant_id = tenant_id

    def list_users(self, page=1, page_size=50, role=None, search=None):
        """Listet Benutzer auf, die diesem Tenant zugewiesen sind."""
        url = f'{BASE_URL}/api/tenant/{self.tenant_id}/user'
        params = {'page': page, 'pageSize': page_size}
        if role:
            params['role'] = role
        if search:
            params['search'] = search

        response = requests.get(url, headers=self.headers, params=params)
        response.raise_for_status()
        return response.json()

    def create_user(self, email, display_name, role_name,
                    first_name=None, last_name=None):
        """Erstellt einen Benutzer und weist ihn einem Tenant zu (oder weist einen bestehenden Benutzer zu)."""
        url = f'{BASE_URL}/api/tenant/{self.tenant_id}/user'
        payload = {
            'email': email,
            'displayName': display_name,
            'roleName': role_name
        }
        if first_name:
            payload['firstName'] = first_name
        if last_name:
            payload['lastName'] = last_name

        response = requests.post(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def assign_user(self, user_id, role_name=None):
        """Weist einem Tenant einen bestehenden Benutzer zu."""
        url = f'{BASE_URL}/api/tenant/{self.tenant_id}/user/{user_id}'
        payload = {}
        if role_name:
            payload['roleName'] = role_name

        response = requests.post(url, json=payload, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def remove_user(self, user_id):
        """Entfernt einen Benutzer von diesem Tenant (löscht den Benutzer nicht)."""
        url = f'{BASE_URL}/api/tenant/{self.tenant_id}/user/{user_id}'
        response = requests.delete(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def get_user(self, user_id):
        """Ruft einen bestimmten Benutzer in diesem Tenant ab."""
        url = f'{BASE_URL}/api/tenant/{self.tenant_id}/user/{user_id}'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

# Verwendung mit Tenant API Key
tenant_id = '12345678-1234-1234-1234-123456789012'
manager = TenantUserManager('your-tenant-api-key', tenant_id)

# Alle Analysten im Tenant auflisten
analysts = manager.list_users(role='Analyst')
print(f"Tenant hat {analysts['totalCount']} Analysten")

for user in analysts['users']:
    print(f"  - {user['displayName']} ({user['email']})")

# Neuen Analysten hinzufügen
new_user = manager.create_user(
    email='new.analyst@example.com',
    display_name='New Analyst',
    role_name='Analyst'
)
print(f"Benutzer hinzugefügt: {new_user['userId']}")

# Benutzer aus Tenant entfernen (Benutzer bleibt im System)
manager.remove_user(new_user['userId'])
print("Benutzer aus Tenant entfernt")

JavaScript/Node.js

const BASE_URL = 'https://your-mindzie-instance.com';

class TenantUserManager {
  constructor(apiKey, tenantId) {
    this.headers = {
      'Authorization': `Bearer ${apiKey}`,
      'Content-Type': 'application/json'
    };
    this.tenantId = tenantId;
  }

  async listUsers(options = {}) {
    const params = new URLSearchParams({
      page: options.page || 1,
      pageSize: options.pageSize || 50
    });
    if (options.role) params.append('role', options.role);
    if (options.search) params.append('search', options.search);

    const url = `${BASE_URL}/api/tenant/${this.tenantId}/user?${params}`;
    const response = await fetch(url, { headers: this.headers });
    if (!response.ok) throw new Error(`Fehler: ${response.status}`);
    return await response.json();
  }

  async createUser(email, displayName, roleName) {
    const url = `${BASE_URL}/api/tenant/${this.tenantId}/user`;
    const response = await fetch(url, {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify({ email, displayName, roleName })
    });
    if (!response.ok) throw new Error(`Fehler: ${response.status}`);
    return await response.json();
  }

  async assignUser(userId, roleName = null) {
    const url = `${BASE_URL}/api/tenant/${this.tenantId}/user/${userId}`;
    const body = roleName ? { roleName } : {};
    const response = await fetch(url, {
      method: 'POST',
      headers: this.headers,
      body: JSON.stringify(body)
    });
    if (!response.ok) throw new Error(`Fehler: ${response.status}`);
    return await response.json();
  }

  async removeUser(userId) {
    const url = `${BASE_URL}/api/tenant/${this.tenantId}/user/${userId}`;
    const response = await fetch(url, {
      method: 'DELETE',
      headers: this.headers
    });
    if (!response.ok) throw new Error(`Fehler: ${response.status}`);
    return await response.json();
  }
}

// Verwendung
const tenantId = '12345678-1234-1234-1234-123456789012';
const manager = new TenantUserManager('your-tenant-api-key', tenantId);

// Benutzer auflisten
const users = await manager.listUsers();
console.log(`Tenant hat ${users.totalCount} Benutzer`);

// Neuen Benutzer hinzufügen
const newUser = await manager.createUser(
  'new@example.com',
  'Neuer Benutzer',
  'Analyst'
);
console.log(`Hinzugefügt: ${newUser.userId}`);

---

Best Practices

1. Verwenden Sie Tenant API Keys: Für die meisten Operationen sind tenant-bezogene Schlüssel sicherer
2. Kapazität prüfen: Überprüfen Sie Tenant-Limits vor der Massenbenutzererstellung
3. Entfernen vs Löschen: Das Entfernen aus dem Tenant belässt Benutzer im System für andere Tenants
4. Vor Erstellung suchen: Prüfen Sie, ob ein Benutzer existiert, bevor Sie ihn erstellen, um Duplikate zu vermeiden