Opérations globales sur les utilisateurs

Les points de terminaison globaux des utilisateurs fournissent des capacités de gestion des utilisateurs à l'échelle du système. Ces points de terminaison nécessitent une clé API globale et peuvent accéder aux utilisateurs de tous les locataires.

Authentification

Tous les points de terminaison de cette page nécessitent une clé API globale. Les clés API spécifiques à un locataire recevront une erreur 401 Unauthorized.

---

Lister tous les utilisateurs

GET /api/user

Récupère une liste paginée de tous les utilisateurs de tous les locataires.

Paramètres de requête

Paramètre	Type	Défaut	Description
page	integer	1	Numéro de page pour la pagination
pageSize	integer	50	Nombre d'éléments par page (max : 1000)
includeDisabled	boolean	false	Inclure les utilisateurs désactivés
role	string	null	Filtrer par nom de rôle
search	string	null	Recherche par email ou nom d’affichage

Réponse (200 OK)

{
  "users": [
    {
      "userId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
      "email": "john.smith@example.com",
      "displayName": "John Smith",
      "firstName": "John",
      "lastName": "Smith",
      "roleName": "Analyst",
      "disabled": false,
      "isServiceAccount": false,
      "homeTenantId": null,
      "homeTenantName": null,
      "lastLogin": "2024-01-15T10:30:00Z",
      "tenantCount": 2,
      "tenantNames": "acme-corp, globex-inc",
      "dateCreated": "2024-01-01T00:00:00Z"
    }
  ],
  "totalCount": 150,
  "page": 1,
  "pageSize": 50
}

Champs de l’objet utilisateur

Champ	Type	Description
userId	GUID	Identifiant unique de l’utilisateur
email	string	Adresse email de l’utilisateur (unique)
displayName	string	Nom d’affichage de l’utilisateur
firstName	string	Prénom de l’utilisateur
lastName	string	Nom de famille de l’utilisateur
roleName	string	Rôle de l’utilisateur (Administrator, TenantAdmin, Analyst, etc.)
disabled	boolean	Indique si le compte utilisateur est désactivé
isServiceAccount	boolean	Indique s’il s’agit d’un compte de service
homeTenantId	GUID	Locataire principal pour les comptes de service
homeTenantName	string	Nom du locataire principal pour les comptes de service
lastLogin	datetime	Date et heure de la dernière connexion
tenantCount	integer	Nombre de locataires auxquels l’utilisateur est affecté
tenantNames	string	Liste des noms de locataires séparés par des virgules
dateCreated	datetime	Date de création du compte

Réponses d’erreur

Non autorisé (401) :

{
  "error": "This endpoint requires a Global API key. Tenant-specific API keys cannot list all users.",
  "hint": "Use /api/tenant/{tenantId}/user to list users for a specific tenant, or create a Global API key at /admin/global-api-keys"
}

---

Créer un utilisateur

POST /api/user

Crée un nouvel utilisateur dans le système. Cela n’assigne PAS l’utilisateur à un 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	string	Oui	Email de l’utilisateur (doit être unique)
displayName	string	Oui	Nom d’affichage (2-100 caractères)
firstName	string	Non	Prénom (max 50 caractères)
lastName	string	Non	Nom de famille (max 50 caractères)
roleName	string	Oui	Nom du rôle (voir Roles & Permissions)

Réponse (201 Created)

{
  "userId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "email": "john.smith@example.com",
  "displayName": "John Smith",
  "message": "User created successfully"
}

Réponses d’erreur

Conflit (409) :

{
  "error": "A user with email 'john.smith@example.com' already exists"
}

---

Obtenir un utilisateur par ID

GET /api/user/{userId}

Récupère les informations détaillées d’un utilisateur spécifique.

Paramètres de chemin

Paramètre	Type	Description
userId	GUID	Identifiant de l’utilisateur

Réponse (200 OK)

Renvoie un objet utilisateur complet avec les affectations aux locataires.

Réponses d’erreur

Non trouvé (404) :

{
  "error": "User not found with ID 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'",
  "userId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
}

---

Mettre à jour un utilisateur

PUT /api/user/{userId}

Met à jour les propriétés de l’utilisateur. Seuls les champs fournis seront modifiés.

Paramètres de chemin

Paramètre	Type	Description
userId	GUID	Identifiant de l’utilisateur

Corps de la requête

{
  "displayName": "Jane Smith",
  "roleName": "TenantAdmin",
  "disabled": false,
  "isServiceAccount": true,
  "homeTenantId": "12345678-1234-1234-1234-123456789012"
}

Champs de la requête

Champ	Type	Obligatoire	Description
displayName	string	Non	Nouveau nom d’affichage
roleName	string	Non	Nouveau nom de rôle
disabled	boolean	Non	Activer/désactiver le compte
isServiceAccount	boolean	Non	Indicateur de compte de service
homeTenantId	GUID	Conditionnel	Obligatoire si le compte devient un compte de service

Règles pour les comptes de service

• Seuls les rôles Administrator et TenantAdmin peuvent être comptes de service
• Lors de la promotion en compte de service, homeTenantId est obligatoire
• Lors de la rétrogradation d’un compte de service, homeTenantId est effacé automatiquement

Réponse (200 OK)

{
  "message": "User updated successfully"
}

---

Obtenir un utilisateur par email

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

Récupère un utilisateur par son adresse email.

Paramètres de chemin

Paramètre	Type	Description
email	string	Adresse email de l’utilisateur (encodée dans l’URL)

Réponse (200 OK)

Renvoie un objet utilisateur complet.

---

Obtenir les locataires d’un utilisateur

GET /api/user/{userId}/tenants

Récupère toutes les affectations de locataires pour un utilisateur.

Paramètres de chemin

Paramètre	Type	Description
userId	GUID	Identifiant de l’utilisateur

Réponse (200 OK)

{
  "userId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
  "email": "john.smith@example.com",
  "displayName": "John Smith",
  "tenants": [
    {
      "tenantId": "12345678-1234-1234-1234-123456789012",
      "tenantName": "acme-corp",
      "displayName": "Acme Corporation",
      "dateAssigned": "2024-01-15T10:30:00Z"
    }
  ]
}

---

Exemples d’implémentation

cURL

# Lister tous les utilisateurs (clé API globale requise)
curl -X GET "https://your-mindzie-instance.com/api/user?page=1&pageSize=50" \
  -H "Authorization: Bearer YOUR_GLOBAL_API_KEY"

# Rechercher des utilisateurs par nom
curl -X GET "https://your-mindzie-instance.com/api/user?search=john" \
  -H "Authorization: Bearer YOUR_GLOBAL_API_KEY"

# Filtrer par rôle
curl -X GET "https://your-mindzie-instance.com/api/user?role=Analyst" \
  -H "Authorization: Bearer YOUR_GLOBAL_API_KEY"

# Créer un nouvel utilisateur
curl -X POST "https://your-mindzie-instance.com/api/user" \
  -H "Authorization: Bearer YOUR_GLOBAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "john.smith@example.com",
    "displayName": "John Smith",
    "roleName": "Analyst"
  }'

# Obtenir un utilisateur par ID
curl -X GET "https://your-mindzie-instance.com/api/user/a1b2c3d4-e5f6-7890-abcd-ef1234567890" \
  -H "Authorization: Bearer YOUR_GLOBAL_API_KEY"

# Obtenir un utilisateur par email
curl -X GET "https://your-mindzie-instance.com/api/user/by-email/john.smith%40example.com" \
  -H "Authorization: Bearer YOUR_GLOBAL_API_KEY"

# Obtenir les locataires d’un utilisateur
curl -X GET "https://your-mindzie-instance.com/api/user/a1b2c3d4-e5f6-7890-abcd-ef1234567890/tenants" \
  -H "Authorization: Bearer YOUR_GLOBAL_API_KEY"

Python

import requests

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

class GlobalUserManager:
    def __init__(self, global_api_key):
        """Initialiser avec une clé API GLOBALE (non spécifique à un locataire)."""
        self.headers = {
            'Authorization': f'Bearer {global_api_key}',
            'Content-Type': 'application/json'
        }

    def list_users(self, page=1, page_size=50, include_disabled=False,
                   role=None, search=None):
        """Lister tous les utilisateurs de tous les locataires."""
        url = f'{BASE_URL}/api/user'
        params = {
            'page': page,
            'pageSize': page_size,
            'includeDisabled': include_disabled
        }
        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 nouvel utilisateur (non assigné à un locataire)."""
        url = f'{BASE_URL}/api/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 get_user(self, user_id):
        """Obtenir un utilisateur par ID."""
        url = f'{BASE_URL}/api/user/{user_id}'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def get_user_by_email(self, email):
        """Obtenir un utilisateur par adresse email."""
        from urllib.parse import quote
        url = f'{BASE_URL}/api/user/by-email/{quote(email, safe="")}'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def update_user(self, user_id, display_name=None, role_name=None,
                    disabled=None, is_service_account=None, home_tenant_id=None):
        """Mettre à jour les propriétés d’un utilisateur."""
        url = f'{BASE_URL}/api/user/{user_id}'
        payload = {}
        if display_name is not None:
            payload['displayName'] = display_name
        if role_name is not None:
            payload['roleName'] = role_name
        if disabled is not None:
            payload['disabled'] = disabled
        if is_service_account is not None:
            payload['isServiceAccount'] = is_service_account
        if home_tenant_id is not None:
            payload['homeTenantId'] = home_tenant_id

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

    def get_user_tenants(self, user_id):
        """Obtenir toutes les affectations de locataires pour un utilisateur."""
        url = f'{BASE_URL}/api/user/{user_id}/tenants'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

# Utilisation
manager = GlobalUserManager('your-global-api-key')

# Lister tous les analystes
analysts = manager.list_users(role='Analyst')
print(f"Total des analystes : {analysts['totalCount']}")

# Créer un nouvel utilisateur
new_user = manager.create_user(
    email='new.analyst@example.com',
    display_name='New Analyst',
    role_name='Analyst',
    first_name='New',
    last_name='Analyst'
)
print(f"Utilisateur créé : {new_user['userId']}")

# Obtenir les affectations de locataires de l’utilisateur
user_id = new_user['userId']
tenants = manager.get_user_tenants(user_id)
print(f"L’utilisateur est assigné à {len(tenants['tenants'])} locataires")

JavaScript/Node.js

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

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

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

    const url = `${BASE_URL}/api/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/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 getUser(userId) {
    const url = `${BASE_URL}/api/user/${userId}`;
    const response = await fetch(url, { headers: this.headers });
    if (!response.ok) throw new Error(`Échec : ${response.status}`);
    return await response.json();
  }

  async getUserTenants(userId) {
    const url = `${BASE_URL}/api/user/${userId}/tenants`;
    const response = await fetch(url, { headers: this.headers });
    if (!response.ok) throw new Error(`Échec : ${response.status}`);
    return await response.json();
  }
}

// Utilisation
const manager = new GlobalUserManager('your-global-api-key');

// Lister tous les utilisateurs
const users = await manager.listUsers();
console.log(`Nombre total d’utilisateurs : ${users.totalCount}`);

// Créer un utilisateur et vérifier les affectations aux locataires
const newUser = await manager.createUser(
  'new@example.com',
  'New User',
  'Analyst'
);
const tenants = await manager.getUserTenants(newUser.userId);
console.log(`Assigné à ${tenants.tenants.length} locataires`);