Opérations sur les Utilisateurs du Locataire

Les points de terminaison des utilisateurs au sein d'un locataire gèrent les utilisateurs dans un locataire spécifique. Ces points de terminaison peuvent être accessibles avec une clé API Globale ou une clé API Locataire.

Authentification

Type de clé API	Accès
Clé API Globale	Peut accéder à n'importe quel locataire
Clé API Locataire	Peut uniquement accéder à son propre locataire

---

Lister les utilisateurs d’un locataire

GET /api/tenant/{tenantId}/user

Récupère les utilisateurs assignés à un locataire spécifique.

Paramètres de chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Identifiant du locataire

Paramètres de requête

Paramètre	Type	Défaut	Description
page	entier	1	Numéro de page pour la pagination
pageSize	entier	50	Nombre d’éléments par page (max : 1000)
includeDisabled	booléen	false	Inclure les utilisateurs désactivés
role	chaîne	null	Filtrer par nom de rôle
search	chaîne	null	Rechercher par email ou nom d’affichage

Réponse (200 OK)

Même structure que la liste globale de tous les utilisateurs, mais filtrée pour le locataire spécifié.

---

Créer un utilisateur dans un locataire

POST /api/tenant/{tenantId}/user

Crée un nouvel utilisateur ET l’assigne au locataire, ou assigne un utilisateur existant au locataire.

Note : Si un utilisateur avec l’email spécifié existe déjà, il sera assigné au locataire au lieu de créer un doublon.

Paramètres de chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Identifiant du locataire

Corps de la requête

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

Champs de la requête

Champ	Type	Obligatoire	Description
email	chaîne	Oui	Adresse email de l’utilisateur
displayName	chaîne	Oui	Nom d’affichage (2-100 caractères)
firstName	chaîne	Non	Prénom (max 50 caractères)
lastName	chaîne	Non	Nom de famille (max 50 caractères)
roleName	chaîne	Oui	Nom du rôle (voir Rôles & Permissions)

Validation de capacité

L’opération vérifie les limites de capacité du locataire :

• La limite MaxUsers est vérifiée pour tous les rôles
• La limite MaxAnalyst est vérifiée pour les rôles Analyst

Réponse (201 Créé)

{
  "userId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "email": "john.smith@example.com",
  "displayName": "John Smith",
  "message": "Utilisateur créé et assigné au locataire avec succès"
}

Réponses d’erreur

Conflit (409) :

{
  "error": "L'utilisateur est déjà assigné à ce locataire"
}

Capacité dépassée (400) :

{
  "error": "Impossible d'ajouter l'utilisateur : le locataire a atteint sa limite maximale d'utilisateurs (100)",
  "hint": "Augmentez la limite d'utilisateurs ou d'analystes du locataire pour ajouter plus d'utilisateurs"
}

---

Obtenir un utilisateur dans un locataire

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

Récupère un utilisateur spécifique dans le contexte du locataire.

Paramètres de chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Identifiant du locataire
userId	GUID	Oui	Identifiant de l'utilisateur

Réponse (200 OK)

Retourne l’objet utilisateur s’il est assigné au locataire.

---

Obtenir un utilisateur par email dans un locataire

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

Récupère un utilisateur par email dans le contexte du locataire.

Paramètres de chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Identifiant du locataire
email	chaîne	Oui	Email de l'utilisateur (encodé URL)

Réponse (200 OK)

Retourne l’objet utilisateur s’il est assigné au locataire.

---

Assigner un utilisateur existant à un locataire

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

Assigne un utilisateur existant à un locataire.

Paramètres de chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Identifiant du locataire
userId	GUID	Oui	Identifiant de l'utilisateur

Corps de la requête (optionnel)

{
  "roleName": "Analyst"
}

Réponse (200 OK)

{
  "message": "Utilisateur assigné au locataire avec succès"
}

---

Mettre à jour un utilisateur dans un locataire

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

Met à jour les propriétés d’un utilisateur dans le contexte du locataire.

Paramètres de chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Identifiant du locataire
userId	GUID	Oui	Identifiant de l'utilisateur

Corps de la requête

{
  "displayName": "Nom mis à jour",
  "roleName": "TenantAdmin"
}

Réponse (200 OK)

{
  "message": "Utilisateur mis à jour avec succès"
}

---

Supprimer un utilisateur d’un locataire

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

Supprime l’assignation d’un utilisateur d’un locataire. Ceci NE supprime PAS l’utilisateur du système.

Paramètres de chemin

Paramètre	Type	Obligatoire	Description
tenantId	GUID	Oui	Identifiant du locataire
userId	GUID	Oui	Identifiant de l'utilisateur

Réponse (200 OK)

{
  "message": "Utilisateur retiré du locataire avec succès"
}

Réponses d’erreur

Non trouvé (404) :

{
  "error": "L'utilisateur n'est pas assigné à ce locataire"
}

---

Exemples d’implémentation

cURL

# Lister les utilisateurs d'un locataire (la clé API locataire fonctionne)
curl -X GET "https://your-mindzie-instance.com/api/tenant/12345678-1234-1234-1234-123456789012/user" \
  -H "Authorization: Bearer YOUR_TENANT_API_KEY"

# Rechercher des utilisateurs dans le locataire
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"

# Créer un utilisateur dans le locataire (crée l'utilisateur ET l’assigne)
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"
  }'

# Assigner un utilisateur existant au locataire
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"}'

# Retirer un utilisateur du locataire
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):
        """
        Initialiser avec une clé API et un ID de locataire.
        Fonctionne avec les clés API Globales ou Locataires.
        """
        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):
        """Lister les utilisateurs assignés à ce locataire."""
        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):
        """Créer un utilisateur et l’assigner au locataire (ou assigner un utilisateur existant)."""
        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):
        """Assigner un utilisateur existant à ce locataire."""
        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):
        """Retirer un utilisateur de ce locataire (ne supprime pas l’utilisateur)."""
        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):
        """Obtenir un utilisateur spécifique dans ce locataire."""
        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()

# Utilisation avec clé API Locataire
tenant_id = '12345678-1234-1234-1234-123456789012'
manager = TenantUserManager('your-tenant-api-key', tenant_id)

# Lister tous les analystes du locataire
analysts = manager.list_users(role='Analyst')
print(f"Le locataire a {analysts['totalCount']} analystes")

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

# Ajouter un nouvel analyste
new_user = manager.create_user(
    email='new.analyst@example.com',
    display_name='New Analyst',
    role_name='Analyst'
)
print(f"Utilisateur ajouté : {new_user['userId']}")

# Retirer l’utilisateur du locataire (il reste dans le système)
manager.remove_user(new_user['userId'])
print("Utilisateur retiré du locataire")

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(`Échec : ${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(`Échec : ${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(`Échec : ${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(`Échec : ${response.status}`);
    return await response.json();
  }
}

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

// Lister les utilisateurs
const users = await manager.listUsers();
console.log(`Le locataire a ${users.totalCount} utilisateurs`);

// Ajouter un nouvel utilisateur
const newUser = await manager.createUser(
  'new@example.com',
  'Nouvel Utilisateur',
  'Analyst'
);
console.log(`Ajouté : ${newUser.userId}`);

---

Bonnes pratiques

1. Utiliser les clés API Locataires : Pour la plupart des opérations, les clés limitées au locataire sont plus sûres
2. Vérifier la capacité : Contrôler les limites du locataire avant la création en masse d’utilisateurs
3. Supprimer vs Retirer : Retirer d’un locataire conserve l’utilisateur dans le système pour d’autres locataires
4. Rechercher avant de créer : Vérifier si l’utilisateur existe avant de créer pour éviter les doublons