> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Script d’action de base de données Delete User et modèles

> Le script Delete s’exécute lorsque vous devez supprimer un utilisateur donné de votre magasin d’utilisateurs externe et il est requis si vous souhaitez également supprimer l’utilisateur d’Auth0 dans la même opération.

Le script Delete implémente la fonction définie pour supprimer un utilisateur donné d’une base de données externe. Nous recommandons de nommer cette fonction `deleteUser`.

Ce script n’est utilisé que dans un [scénario d’authentification héritée](/docs/fr-ca/authenticate/database-connections/custom-db/overview-custom-db-connections) et il est requis si vous souhaitez supprimer un utilisateur d’Auth0 et de votre base de données externe dans la même opération.

<div id="deleteuser-function">
  ## Fonction DeleteUser
</div>

La fonction `deleteUser` doit :

* Supprimer l’utilisateur spécifié de la base de données externe.
* Retourner une valeur `null` si la suppression a réussi.
* Retourner une erreur si la suppression a échoué.

<div id="definition">
  ### Définition
</div>

La fonction `deleteUser` accepte deux paramètres et renvoie une fonction de rappel :

```js lines theme={null}
deleteUser(id, callback): function
```

| Paramètre  | Type     | Description                                                                   |
| ---------- | -------- | ----------------------------------------------------------------------------- |
| `id`       | String   | L’identity `user_id` de l’utilisateur. Ne commence pas par `auth0`.           |
| `callback` | Function | Utilisé pour transmettre une erreur ou des données de profil via le pipeline. |

Voici un pseudo-exemple en Javascript illustrant comment vous pourriez implémenter la fonction `deleteUser` :

```javascript lines theme={null}
function deleteUser(id, callback) {
  // Envoyer l'identifiant de l'utilisateur à l'API de base de données externe
  let options = {
    url: "https://example.com/api/deleteUser",
    body: {
      id: id
    }
  };

  send(options, (err, profileData) => {
    // Retourner une erreur dans le callback si la suppression a échoué
    if (err) {
      return callback(new Error("My custom error message."));
    }

    // Retourner une valeur null dans le callback si la suppression a réussi
    return callback(null);
  });
}
```

<div id="callback-function">
  ## Fonction de rappel
</div>

La fonction `callback` accepte un paramètre et renvoie une fonction.

<div id="definition">
  ### Définition
</div>

```js lines theme={null}
callback(error): function
```

| Paramètre | Type  | Obligatoire | Description                    |
| --------- | ----- | ----------- | ------------------------------ |
| `error`   | Objet | Obligatoire | Contient les données d’erreur. |

<div id="return-a-success">
  ### Retourner une réussite
</div>

Si l’utilisateur a bien été supprimé de votre base de données externe, appelez la fonction de rappel et transmettez une valeur `null` pour le paramètre `error` :

```js lines theme={null}
return callback(null);
```

<div id="return-an-error">
  ### Retourner une erreur
</div>

Si une erreur se produit, appelez la fonction de rappel et transmettez au paramètre `error` les renseignements pertinents sur l’erreur :

```js lines theme={null}
return callback(new Error("My custom error message."));
```

<div id="language-specific-script-examples">
  ## Exemples de scripts par langage
</div>

Auth0 fournit des exemples de scripts à utiliser avec les langages et technologies suivants :

<CodeGroup>
  ```javascript JavaScript lines theme={null}
  function remove (id, callback) {
    // Ce script supprime un utilisateur de votre base de données existante.
    // Il est exécuté chaque fois qu'un utilisateur est supprimé à partir de la Management API ou du tableau de bord Auth0.
    //
    // Ce script peut se terminer de deux façons :
    // 1. L'utilisateur a été supprimé avec succès :
    //     callback(null);
    // 2. Un problème est survenu en tentant d'accéder à votre base de données :
    //     callback(new Error("my error message"));
    var msg = "Please implement the Delete script for this database " +
         "connection at https://manage.auth0.com/#/connections/database";
    return callback(new Error(msg));
  }
  ```

  ```javascript ASP.NET MVC3 lines expandable theme={null}
  // Pour ASP.NET Membership Provider (MVC3 - fournisseurs Universal)
  function remove(id, callback) {
    const sqlserver = require('tedious@1.11.0');
    const Connection = sqlserver.Connection;
    const Request = sqlserver.Request;
    const TYPES = sqlserver.TYPES;
    const connection = new Connection({
      userName: 'the username',
      password: 'the password',
      server: 'the server',
      options: {
        database: 'the db name',
        encrypt: true,
        // Requis pour récupérer l'userId nécessaire à la création de l'entité Membership
        rowCollectionOnRequestCompletion: true
      }
    });
    connection.on('debug', function(text) {
      // si vous avez des problèmes de connexion, décommentez ceci pour obtenir des informations plus détaillées
      // console.log(text);
    }).on('errorMessage', function(text) {
      // ceci affichera toutes les erreurs lors de la connexion à la base de données SQL ou avec les instructions SQL
      console.log(JSON.stringify(text));
    });
    connection.on('connect', function(err) {
      if (err) return callback(err);
      executeDelete(['Memberships', 'Users'], function(err) {
        if (err) return callback(err);
        callback(null);
      });
    });
    function executeDelete(tables, callback) {
      const query = tables.map(function(table) {
        return 'DELETE FROM ' + table + ' WHERE UserId = @UserId';
      }).join(';');
      const request = new Request(query, function(err) {
        if (err) return callback(err);
        callback(null);
      });
      request.addParameter('UserId', TYPES.VarChar, id);
      connection.execSql(request);
    }
  }
  ```

  ```javascript ASP.NET MVC4 lines expandable theme={null}
  // Pour ASP.NET Membership Provider (MVC4 - Simple Membership)
  function remove(id, callback) {
    const sqlserver = require('tedious@1.11.0');
    const Connection = sqlserver.Connection;
    const Request = sqlserver.Request;
    const TYPES = sqlserver.TYPES;
    const connection = new Connection({
      userName: 'the username',
      password: 'the password',
      server: 'the server',
      options: {
        database: 'the db name',
        encrypt: true,
        // Requis pour récupérer l'userId nécessaire à la création de l'entité Membership
        rowCollectionOnRequestCompletion: true
      }
    });
    connection.on('debug', function (text) {
      // si vous avez des problèmes de connexion, décommentez ceci pour obtenir des informations plus détaillées
      // console.log(text);
    }).on('errorMessage', function (text) {
      // ceci affichera toutes les erreurs lors de la connexion à la base de données SQL ou avec les instructions SQL
      console.log(JSON.stringify(text));
    });
    connection.on('connect', function (err) {
      if (err) return callback(err);
      executeDelete(['webpages_Membership', 'UserProfile'], function (err) {
        if (err) return callback(err);
        callback(null);
      });
    });
    function executeDelete(tables, callback) {
      const query = tables.map(function (table) {
        return 'DELETE FROM ' + table + ' WHERE UserId = @UserId';
      }).join(';');
      const request = new Request(query, function (err) {
        if (err) return callback(err);
        callback(null);
      });
      request.addParameter('UserId', TYPES.VarChar, id);
      connection.execSql(request);
    }
  }
  ```

  ```javascript MongoDB lines theme={null}
  function remove(id, callback) {
    const MongoClient = require('mongodb@3.1.4').MongoClient;
    const client = new MongoClient('mongodb://user:pass@mymongoserver.com');
    client.connect(function (err) {
      if (err) return callback(err);
      const db = client.db('db-name');
      const users = db.collection('users');
      users.remove({ _id: id }, function (err) {
        client.close();
        if (err) return callback(err);
        callback(null);
      });
    });
  }
  ```

  ```javascript MySQL lines theme={null}
  function remove(id, callback) {
    const mysql = require('mysql');
    const connection = mysql({
      host: 'localhost',
      user: 'me',
      password: 'secret',
      database: 'mydb'
    });
    connection.connect();
    const query = 'DELETE FROM users WHERE id = ?';
    connection.query(query, [ id ], function(err) {
      if (err) return callback(err);
      callback(null);
    });
  }
  ```

  ```javascript PostgreSQL lines theme={null}
  function remove(id, callback) {
    //cet exemple utilise la bibliothèque « pg »
    //plus d'infos ici : https://github.com/brianc/node-postgres
    const postgres = require('pg');
    const conString = 'postgres://user:pass@localhost/mydb';
    postgres.connect(conString, function (err, client, done) {
      if (err) return callback(err);
      const query = 'DELETE FROM users WHERE id = $1';
      client.query(query, [id], function (err) {
        // REMARQUE : appelez toujours `done()` ici pour fermer
        // la connexion à la base de données
        done();
        return callback(err);
      });
    });
  }
  ```

  ```javascript SQL Server lines expandable theme={null}
  function remove(id, callback) {
    // cet exemple utilise la bibliothèque « tedious »
    // plus d’informations ici : http://pekim.github.io/tedious/index.html
    const sqlserver = require('tedious@1.11.0');
    const Connection = sqlserver.Connection;
    const Request = sqlserver.Request;
    const TYPES = sqlserver.TYPES;
    const connection = new Connection({
      userName:  'test',
      password:  'test',
      server:    'localhost',
      options:  {
        database: 'mydb'
      }
    });
    const query = 'DELETE FROM dbo.Users WHERE id = @UserId';
    connection.on('debug', function (text) {
      console.log(text);
    }).on('errorMessage', function (text) {
      console.log(JSON.stringify(text, null, 2));
    }).on('infoMessage', function (text) {
      console.log(JSON.stringify(text, null, 2));
    });
    connection.on('connect', function (err) {
      if (err) return callback(err);
      const request = new Request(query, function (err) {
        if (err) return callback(err);
        callback(null);
      });
      request.addParameter('UserId', TYPES.VarChar, id);
      connection.execSql(request);
    });
  }
  ```

  ```javascript Azure SQL Database lines expandable theme={null}
  function remove (id, callback) {
    // cet exemple utilise la bibliothèque « tedious »
    // plus d’informations ici : http://pekim.github.io/tedious/index.html
    var Connection = require('tedious@1.11.0').Connection;
    var Request = require('tedious@1.11.0').Request;
    var TYPES = require('tedious@1.11.0').TYPES;
    var connection = new Connection({
      userName: 'your-user@your-server-id.database.windows.net',
      password: 'the-password',
      server: 'your-server-id.database.windows.net',
      options: {
        database: 'mydb',
        encrypt: true
      }
    });
    connection.on('debug', function (text) {
      console.log(text);
    }).on('errorMessage', function (text) {
      console.log(JSON.stringify(text, null, 2));
    }).on('infoMessage', function (text) {
      console.log(JSON.stringify(text, null, 2));
    });
    connection.on('connect', function (err) {
      if (err) { return callback(err); }
      var query = 'DELETE FROM users WHERE id = @UserId';
      var request = new Request(query, function (err) {
        if (err) { return callback(err); }
        callback(null);
      });
      request.addParameter('UserId', TYPES.VarChar, id);
      connection.execSql(request);
    });
  }
  ```
</CodeGroup>