Suppression de locataire

Supprimez définitivement un locataire et toutes les données associées. Cette opération nécessite une triple vérification pour des raisons de sécurité.

IMPORTANT : Tous les points de terminaison de cette page requièrent une clé API globale. Il s'agit d'une opération dangereuse et irréversible.

---

Supprimer un locataire

DELETE /api/tenant

Supprime définitivement un locataire et toutes les données associées. Nécessite une triple vérification pour des raisons de sécurité.

AVERTISSEMENT

Cette opération est IRRÉVERSIBLE. Toutes les données du locataire seront définitivement supprimées, y compris :

• Tous les projets et leurs jeux de données
• Toutes les investigations, carnets, et tableaux de bord
• Le conteneur de stockage Blob et les fichiers
• Les enregistrements et les paramètres de la base de données
• Les affectations des utilisateurs au locataire (les utilisateurs eux-mêmes ne sont pas supprimés)

Exportez toujours les données importantes avant de supprimer un locataire.

---

Corps de la requête

{
  "tenantId": "12345678-1234-1234-1234-123456789012",
  "name": "acme-corp",
  "displayName": "Acme Corporation"
}

Triple vérification

Les trois identifiants doivent correspondre exactement pour que la suppression puisse avoir lieu :

Champ	Type	Obligatoire	Description
tenantId	GUID	Oui	ID du locataire à supprimer
name	string	Oui	Nom du locataire (doit correspondre exactement)
displayName	string	Oui	Nom affiché (doit correspondre exactement)

Cette triple vérification empêche les suppressions accidentelles en exigeant que vous connaissiez et confirmiez les trois identifiants.

---

Réponse (200 OK)

{
  "message": "Tenant 'Acme Corporation' deleted successfully",
  "tenantName": "acme-corp",
  "tenantDisplayName": "Acme Corporation",
  "storageContainerDeleted": true
}

Champs de la réponse

Champ	Type	Description
message	string	Message de confirmation de succès
tenantName	string	Nom système du locataire supprimé
tenantDisplayName	string	Nom affiché du locataire supprimé
storageContainerDeleted	boolean	Indique si le stockage blob a été supprimé

---

Réponses d'erreur

Non trouvé (404)

{
  "error": "Tenant not found with ID '12345678-1234-1234-1234-123456789012'"
}

Vérification échouée (400)

Lorsque le nom du locataire ne correspond pas :

{
  "error": "Tenant name 'wrong-name' does not match the tenant with ID '12345678-1234-1234-1234-123456789012'. Expected 'acme-corp'.",
  "hint": "All three identifiers (ID, name, display name) must match exactly for safety"
}

Lorsque le nom affiché ne correspond pas :

{
  "error": "Display name 'Wrong Name' does not match the tenant with ID '12345678-1234-1234-1234-123456789012'. Expected 'Acme Corporation'.",
  "hint": "All three identifiers (ID, name, display name) must match exactly for safety"
}

Non autorisé (401)

{
  "error": "This endpoint requires a Global API key.",
  "hint": "Global API keys can be created at /admin/global-api-keys"
}

---

Exemples d'implémentation

cURL

# Supprimer un locataire (nécessite une triple vérification)
curl -X DELETE "https://your-mindzie-instance.com/api/tenant" \
  -H "Authorization: Bearer YOUR_GLOBAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "tenantId": "12345678-1234-1234-1234-123456789012",
    "name": "test-tenant",
    "displayName": "Test Tenant"
  }'

Python

import requests

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

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

    def get_tenant(self, tenant_id):
        """Obtenir les détails du locataire pour vérification."""
        url = f'{BASE_URL}/api/tenant/{tenant_id}'
        response = requests.get(url, headers=self.headers)
        response.raise_for_status()
        return response.json()

    def delete_tenant(self, tenant_id, name, display_name, confirm=False):
        """
        Supprimer un locataire avec triple vérification.

        Args:
            tenant_id: GUID du locataire
            name: Nom système du locataire (doit correspondre exactement)
            display_name: Nom affiché du locataire (doit correspondre exactement)
            confirm: Mettre à True pour effectuer la suppression réelle
        """
        if not confirm:
            # Mode vérification - vérifier que les valeurs correspondent
            tenant = self.get_tenant(tenant_id)

            errors = []
            if tenant['name'] != name:
                errors.append(f"Incohérence du nom : attendu '{tenant['name']}', reçu '{name}'")
            if tenant['displayName'] != display_name:
                errors.append(f"Incohérence du nom affiché : attendu '{tenant['displayName']}', reçu '{display_name}'")

            if errors:
                raise ValueError("Échec de la vérification :\n" + "\n".join(errors))

            print(f"Vérification réussie pour le locataire '{display_name}' ({name})")
            print(f"  - ID : {tenant_id}")
            print(f"  - Utilisateurs : {tenant.get('userCount', 'N/A')}")
            print(f"  - Cas : {tenant.get('caseCount', 'N/A')}")
            print("\nAppelez la méthode avec confirm=True pour procéder à la suppression.")
            return None

        # Effectuer la suppression
        url = f'{BASE_URL}/api/tenant'
        payload = {
            'tenantId': tenant_id,
            'name': name,
            'displayName': display_name
        }

        response = requests.delete(url, json=payload, headers=self.headers)

        if response.ok:
            return response.json()
        elif response.status_code == 404:
            raise Exception(f'Locataire non trouvé : {tenant_id}')
        elif response.status_code == 400:
            error = response.json()
            raise Exception(f"Échec de la vérification : {error.get('error', 'Erreur inconnue')}")
        else:
            raise Exception(f'Échec de la suppression du locataire : {response.text}')

# Utilisation - Procédure de suppression sécurisée
deleter = TenantDeleter('your-global-api-key')

tenant_id = '12345678-1234-1234-1234-123456789012'
tenant_name = 'test-tenant'
display_name = 'Test Tenant'

# Étape 1 : Vérifier (aucune suppression ne se produit)
try:
    deleter.delete_tenant(tenant_id, tenant_name, display_name, confirm=False)
except ValueError as e:
    print(f"Échec de la vérification : {e}")
    exit(1)

# Étape 2 : Confirmer la suppression (décommentez lorsque prêt)
# result = deleter.delete_tenant(tenant_id, tenant_name, display_name, confirm=True)
# print(f"Supprimé : {result['message']}")

JavaScript

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

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

  async getTenant(tenantId) {
    const url = `${BASE_URL}/api/tenant/${tenantId}`;
    const response = await fetch(url, { headers: this.headers });
    if (!response.ok) throw new Error(`Échec de récupération du locataire : ${response.status}`);
    return await response.json();
  }

  async deleteTenant(tenantId, name, displayName, confirm = false) {
    if (!confirm) {
      // Mode vérification
      const tenant = await this.getTenant(tenantId);

      const errors = [];
      if (tenant.name !== name) {
        errors.push(`Incohérence du nom : attendu '${tenant.name}', reçu '${name}'`);
      }
      if (tenant.displayName !== displayName) {
        errors.push(`Incohérence du nom affiché : attendu '${tenant.displayName}', reçu '${displayName}'`);
      }

      if (errors.length > 0) {
        throw new Error('Échec de la vérification :\n' + errors.join('\n'));
      }

      console.log(`Vérification réussie pour le locataire '${displayName}' (${name})`);
      console.log(`  - ID : ${tenantId}`);
      console.log(`  - Utilisateurs : ${tenant.userCount || 'N/A'}`);
      console.log('\nAppelez avec confirm=true pour procéder à la suppression.');
      return null;
    }

    // Effectuer la suppression
    const url = `${BASE_URL}/api/tenant`;
    const response = await fetch(url, {
      method: 'DELETE',
      headers: this.headers,
      body: JSON.stringify({ tenantId, name, displayName })
    });

    if (response.ok) {
      return await response.json();
    }

    const error = await response.json();
    throw new Error(error.error || `Échec de la suppression : ${response.status}`);
  }
}

// Utilisation - Procédure de suppression sécurisée
const deleter = new TenantDeleter('your-global-api-key');

const tenantId = '12345678-1234-1234-1234-123456789012';
const tenantName = 'test-tenant';
const displayName = 'Test Tenant';

// Étape 1 : Vérifier (aucune suppression ne se produit)
try {
  await deleter.deleteTenant(tenantId, tenantName, displayName, false);
} catch (e) {
  console.error(`Échec de la vérification : ${e.message}`);
  process.exit(1);
}

// Étape 2 : Confirmer la suppression (décommentez lorsque prêt)
// const result = await deleter.deleteTenant(tenantId, tenantName, displayName, true);
// console.log(`Supprimé : ${result.message}`);

---

Bonnes pratiques de sécurité

Avant la suppression

1. Exporter toutes les données : Utilisez l'API Projet pour exporter tous les projets au format .mpz
2. Vérifier les utilisateurs : Contrôlez quels utilisateurs sont assignés et prévenez-les
3. Documenter : Enregistrez ce qui est supprimé et pourquoi pour les audits
4. Re-vérifier : Vérifiez que l'ID, le nom et le nom affiché du locataire sont corrects

Pendant la suppression

1. Utiliser le mode vérification : Appelez d'abord le point de terminaison delete en mode vérification uniquement
2. Vérifier la réponse : Assurez-vous que la réponse montre les bonnes informations du locataire
3. Confirmer délibérément : Passez à confirm=True seulement après vérification manuelle

Après la suppression

1. Vérifier la suppression : Confirmez que le locataire n'apparaît plus dans la liste
2. Vérifier les utilisateurs : Assurez-vous que les utilisateurs concernés ne peuvent plus accéder au locataire supprimé
3. Mettre à jour la documentation : Enregistrez la suppression dans votre documentation système

---

Alternative : désactiver au lieu de supprimer

Envisagez de désactiver un locataire plutôt que de le supprimer pour conserver les données tout en empêchant l'accès :

# Désactiver un locataire (conserve les données)
curl -X PUT "https://your-mindzie-instance.com/api/tenant" \
  -H "Authorization: Bearer YOUR_GLOBAL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "tenantId": "12345678-1234-1234-1234-123456789012",
    "isDisabled": true
  }'

Les locataires désactivés :

• Les utilisateurs ne peuvent pas se connecter au locataire
• Toutes les données sont conservées
• Peut être réactivé ultérieurement en mettant isDisabled: false
• Apparaissent dans la liste des locataires avec isDisabled: true

C'est souvent une solution plus sûre que la suppression définitive.