> ## 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.

> Décrit les modèles de scripts d’action de base de données personnalisée pour la recherche d’utilisateurs.

# Modèles de scripts Get User

Le script Get User implémente la fonction exécutée pour déterminer si un utilisateur existe actuellement. Nous vous recommandons de nommer cette fonction `getUser`.

Ce script est requis pour la [migration automatique](/fr-CA/docs/manage-users/user-migration/configure-automatic-migration-from-your-database) et, selon les opérations configurées pour la connexion, peut aussi être requis pour l’authentification héritée. Auth0 vous recommande de définir un `user_id` permanent dans le profil utilisateur renvoyé afin d’éviter la création d’utilisateurs en double.

Si la migration automatique est configurée pour la connexion et que le profil utilisateur n’a pas encore été créé, le script est exécuté chaque fois que l’une des opérations suivantes se produit :

* Changement de courriel
* Inscription
* Réinitialisation du mot de passe

Si l’authentification héritée est configurée pour la connexion, le script est exécuté chaque fois que l’une des opérations suivantes se produit :

* Création d’utilisateur
* Changement de courriel
* Changement de mot de passe
* Réinitialisation du mot de passe

<div id="get-user-function">
  ## Fonction `getUser`
</div>

La fonction `getUser` doit :

* Envoyer l’identifiant de l’utilisateur à l’API de la base de données externe.
* Retourner les données de profil de l’utilisateur si celui-ci a été trouvé.
* Retourner une erreur s’il y a eu un problème pour déterminer si l’utilisateur existe ou non.

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

La fonction `getUser` prend deux paramètres et retourne une fonction `callback` :

```js lines theme={null}
getUser(email, callback): function
```

| Paramètre  | Type     | Description                                                              |
| ---------- | -------- | ------------------------------------------------------------------------ |
| `email`    | String   | L’adresse courriel de l’utilisateur.                                     |
| `callback` | Function | Sert à transmettre les erreurs ou les données de profil dans le pipeline |

### Exemple

Voici un exemple en pseudo-JavaScript montrant comment vous pourriez implémenter la fonction `getUser`. Pour des exemples propres à chaque langage, consultez [Exemples de scripts par langage](#language-specific-script-examples).

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

  send(options, (err, profileData) => {
    // Retourner une erreur dans le rappel s'il y a eu un problème lors de la recherche de l'utilisateur
    if (err) {
      return callback(new Error("Could not determine if user exists or not."));
    } else {
      // Retourner null dans le rappel si l'utilisateur n'a pas été trouvé, retourner les données de profil dans le rappel si l'utilisateur a été trouvé
      if (!profileData) {
        return callback(null);
      } else {
        let profile = {
          email: profileData.email,
          user_id: profileData.userId
        };

        return callback(null, profile);
      }
    }
  });
}
```

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

La fonction `callback` sert à transmettre les données de profil de l’utilisateur ou les données d’erreur dans le pipeline.

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

La fonction `callback` accepte un maximum de deux paramètres et renvoie une fonction :

```js lines theme={null}
callback(error[,profile]): function
```

| Paramètre | Type   | Obligatoire | Description                                      |
| --------- | ------ | ----------- | ------------------------------------------------ |
| `error`   | Object | Obligatoire | Contient les données d’erreur.                   |
| `profile` | Object | Facultatif  | Contient les données du profil de l’utilisateur. |

<div id="return-the-user-profile-user-found">
  ### Retourner le profil de l’utilisateur (utilisateur trouvé)
</div>

<Warning>
  Les données de profil renvoyées par le script Get User pour un utilisateur doivent correspondre à celles renvoyées par le script Login.
</Warning>

Si l’utilisateur est trouvé, transmettez la valeur `null` au paramètre `error`, puis transmettez les données de profil de l’utilisateur au paramètre `profile` sous [forme normalisée](/fr-CA/docs/manage-users/user-accounts/user-profiles/normalized-user-profile-schema). En plus des champs standard, vous pouvez inclure les champs `user_metadata`, `app_metadata` et `mfa_factors`.

<div id="example">
  #### Exemple
</div>

```js lines theme={null}
return callback(null, {
    username: "username",
    user_id: "my-custom-db|username@domain.com",
    email: "username@domain.com",
    email_verified: false,
    user_metadata: {
        language: "en"
    },
    app_metadata: {
        plan: "full"
    },
    mfa_factors: [
      {
        phone: {
          value: "+15551234567"
        }
      },
    ]
});
```

<div id="return-no-user-profile-user-not-found">
  ### Ne renvoyez aucun profil d’utilisateur (utilisateur introuvable)
</div>

Si l’utilisateur est introuvable, transmettez une valeur `null` au paramètre `error` et omettez le paramètre `profile`.

<div id="example">
  #### Exemple
</div>

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

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

Si une erreur se produit, transmettez les données d’erreur au paramètre `error` avec des renseignements pertinents sur l’erreur. Pour en savoir plus, consultez [Résoudre les problèmes liés aux bases de données personnalisées](/fr-CA/docs/authenticate/database-connections/custom-db/error-handling).

<div id="example">
  #### Exemple
</div>

```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 pour les langages et technologies suivants :

* [JavaScript](#javascript)
* [ASP.NET Membership Provider (MVC3 - Universal Providers)](#asp-net-membership-provider-mvc3-universal-providers-)
* [ASP.NET Membership Provider (MVC4 - Simple Membership)](#asp-net-membership-provider-mvc4-simple-membership-)
* [MongoDB](#mongodb)
* [MySQL](#mysql)
* [PostgreSQL](#postgresql)
* [SQL Server](#sql-server)
* [Windows Azure SQL Database](#windows-azure-sql-database)
* [Axios](#axios)
* [Stormpath](#stormpath)

<div id="javascript">
  ### JavaScript
</div>

```javascript lines theme={null}
function getByEmail(email, callback) {
  // Ce script doit récupérer un profil utilisateur depuis votre base de données existante,
  // sans authentifier l'utilisateur.
  // Il sert à vérifier si un utilisateur existe avant d'exécuter des flux qui ne
  // nécessitent pas d'authentification (inscription et réinitialisation du mot de passe).
  //
  // Ce script peut se terminer de trois façons :
  // 1. Un utilisateur a été trouvé avec succès. Le profil doit être au format suivant :
  // https://auth0.com/docs/users/normalized/auth0/normalized-user-profile-schema.
  //     callback(null, profile);
  // 2. Aucun utilisateur n'a été trouvé
  //     callback(null);
  // 3. Une erreur s'est produite lors de la tentative d'accès à votre base de données :
  //     callback(new Error("my error message"));
  const msg = 'Please implement the Get User script for this database connection ' +
    'at https://manage.auth0.com/#/connections/database';
  return callback(new Error(msg));
}
```

<div id="aspnet-membership-provider-mvc3-universal-providers">
  ### ASP.NET Membership Provider (MVC3 - Universal Providers)
</div>

```javascript lines expandable theme={null}
function getByEmail(email, 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 // for Windows Azure
    }
  });
  connection.on('debug', function(text) {
    // si vous avez des problèmes de connexion, décommentez cette ligne pour obtenir plus de détails
    //console.log(text);
  }).on('errorMessage', function(text) {
    // ceci affichera toutes les erreurs lors de la connexion à la base de données SQL ou dans les instructions SQL
    console.log(JSON.stringify(text));
  });
  connection.on('connect', function(err) {
    if (err) return callback(err);
    var user = {};
    const query =
      'SELECT Memberships.UserId, Email, Users.UserName ' +
      'FROM Memberships INNER JOIN Users ' +
      'ON Users.UserId = Memberships.UserId ' +
      'WHERE Memberships.Email = @Username OR Users.UserName = @Username';
    const getMembershipQuery = new Request(query, function(err, rowCount) {
      if (err) return callback(err);
      if (rowCount < 1) return callback();
      callback(null, user);
    });
    getMembershipQuery.addParameter('Username', TYPES.VarChar, email);
    getMembershipQuery.on('row', function(fields) {
      user = {
        user_id: fields.UserId.value,
        nickname: fields.UserName.value,
        email: fields.Email.value
      };
    });
    connection.execSql(getMembershipQuery);
  });
}
```

<div id="aspnet-membership-provider-mvc4-simple-membership">
  ### ASP.NET Membership Provider (MVC4 - Simple Membership)
</div>

```javascript lines expandable theme={null}
function getByEmail(email, 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 // pour Windows Azure
    }
  });
  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) {
    // affiche les erreurs lors de la connexion à la base de données SQL ou lors de l'exécution des instructions SQL
    console.log(JSON.stringify(text));
  });
  connection.on('connect', function(err) {
    if (err) return callback(err);
    var user = {};
    const query =
      'SELECT webpages_Membership.UserId, UserName, UserProfile.UserName from webpages_Membership ' +
      'INNER JOIN UserProfile ON UserProfile.UserId = webpages_Membership.UserId ' +
      'WHERE UserProfile.UserName = @Username';
    const getMembershipQuery = new Request(query, function (err, rowCount) {
      if (err) return callback(err);
      if (rowCount < 1) return callback();
      callback(null, user);
    });
    getMembershipQuery.addParameter('Username', TYPES.VarChar, email);
    getMembershipQuery.on('row', function (fields) {
      user = {
        user_id: fields.UserId.value,
        nickname: fields.UserName.value,
        email: fields.UserName.value
      };
    });
    connection.execSql(getMembershipQuery);
  });
}
```

<div id="mongodb">
  ### MongoDB
</div>

```javascript lines theme={null}
function getByEmail(email, callback) {
  const MongoClient = require('mongodb@5.1.0').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.findOne({ email: email }, function (err, user) {
      client.close();
      if (err) return callback(err);
      if (!user) return callback(null, null);
      return callback(null, {
        user_id: user._id.toString(),
        nickname: user.nickname,
        email: user.email
      });
    });
  });
}
```

<div id="mysql">
  ### MySQL
</div>

```javascript lines theme={null}
function getByEmail(email, callback) {
  const mysql = require('mysql');
  const connection = mysql({
    host: 'localhost',
    user: 'me',
    password: 'secret',
    database: 'mydb'
  });
  connection.connect();
  const query = 'SELECT id, nickname, email FROM users WHERE email = ?';
  connection.query(query, [ email ], function(err, results) {
    if (err || results.length === 0) return callback(err || null);
    const user = results[0];
    callback(null, {
      user_id: user.id.toString(),
      nickname: user.nickname,
      email: user.email
    });
  });
}
```

<div id="postgresql">
  ### PostgreSQL
</div>

```javascript lines theme={null}
function loginByEmail(email, callback) {
  //cet exemple utilise la bibliothèque "pg"
  //plus d'informations 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 = 'SELECT id, nickname, email FROM users WHERE email = $1';
    client.query(query, [email], function (err, result) {
      // REMARQUE : appelez toujours `done()` ici pour fermer
      // la connexion à la base de données
      done();
      if (err || result.rows.length === 0) return callback(err);
      const user = result.rows[0];
      return callback(null, {
        user_id: user.id,
        nickname: user.nickname,
        email: user.email
      });
    });
  });
}
```

<div id="sql-server">
  ### SQL Server
</div>

```javascript lines expandable theme={null}
function getByEmail(email, 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 = 'SELECT Id, Nickname, Email FROM dbo.Users WHERE Email = @Email';
  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, rowCount, rows) {
      if (err) return callback(err);
      callback(null, {
        user_id: rows[0][0].value,
        nickname: rows[0][1].value,
        email: rows[0][2].value
      });
    });
    request.addParameter('Email', TYPES.VarChar, email);
    connection.execSql(request);
  });
}
```

<div id="windows-azure-sql-database">
  ### Windows Azure SQL Database
</div>

```javascript lines theme={null}
function getByEmail (name, callback) {
  var profile = {
    user_id:     "103547991597142817347",
    nickname:    "johnfoo",
    email:       "johnfoo@gmail.com",
    name:        "John Foo",
    given_name:  "John",
    family_name: "Foo"
  };
  callback(null, profile);
}
```

<div id="axios">
  ### Axios
</div>

```js lines expandable theme={null}
async function getUserAsync(email, callback) {
  //à mettre à jour lorsque de nouvelles versions d'axios sont disponibles (https://auth0-extensions.github.io/canirequire/#axios)
  const axios = require("axios@0.22.0");

  let response;

  try {
    response = await axios.post(
      //stocker l'URL de l'API dans les paramètres de connexion pour mieux prendre en charge les environnements SDLC
      configuration.baseAPIUrl + "/getUser",
      //identifiants de l'utilisateur transmis dans le corps de la requête
      {
        email: email,
      },
      {
        timeout: 10000, //terminer l'appel proprement si la requête expire afin que le script puisse effectuer le rappel nécessaire
        headers: {
          //sécurisation de l'appel API avec l'apiKey stockée dans les paramètres de connexion.
          //approche simple et rapide, mais l'utilisation de jetons M2M est plus sécurisée car
          // un secret ne doit pas être partagé entre l'application et l'API.
          "x-api-key": configuration.apiKey,
        },
      }
    );
  } catch (e) {
    if (e.response.status === 404) {
      //supposant que l'API retourne 404 lorsqu'aucun utilisateur avec le courriel/nom d'utilisateur spécifié n'est trouvé
      return callback(null, null);
    }
    //rappel pour tout autre type d'erreur
    return callback(new Error(e.message));
  }

  try {
    let user = response.data;

    //si vous utilisez plusieurs connexions de base de données personnalisées dans votre locataire, préfixez le
    //user_id avec une clé propre à la connexion, ex. : "connName|" + user.user_id
    //cela garantit des identifiants d'utilisateur uniques pour toutes les connexions de base de données
    return callback(null, {
      user_id: user.user_id,
      email: user.email,
    });
  } catch (e) {
    return callback(new Error(e.message));
  }
}
```

<div id="stormpath">
  ### Stormpath
</div>

```javascript lines expandable theme={null}
function getByEmail(email, callback) {
  // Remplacez {yourStormpathClientId} par votre ID Stormpath
  var url = 'https://api.stormpath.com/v1/applications/{yourStormpathClientId}/accounts';
  // Ajoutez votre ID client et votre secret d'API Stormpath
  var apiCredentials = {
    user : '{yourStormpathApiId}',
    password: '{yourStormpathApiSecret}'
  };
  // Effectuez une requête GET pour trouver un utilisateur par courriel
  request({
    url: url,
    method: 'GET',
    auth: apiCredentials,
    qs: { q: email },
    json: true
  }, function (error, response, body) {
    if (response.statusCode !== 200) return callback();
    var user = body.items[0];
    if (!user) return callback();
    var id = user.href.replace('https://api.stormpath.com/v1/accounts/', '');
    return callback(null, {
      user_id: id,
      username: user.username,
      email: user.email,
      email_verified: true
      // Ajoutez tout champ supplémentaire que vous souhaitez transférer depuis Stormpath
    });
  });
}
```

<div id="learn-more">
  ## En savoir plus
</div>

* [Modèles de script pour modifier le mot de passe](/fr-CA/docs/authenticate/database-connections/custom-db/templates/change-password)
* [Modèles de script pour la création](/fr-CA/docs/authenticate/database-connections/custom-db/templates/create)
* [Modèles de script pour la suppression](/fr-CA/docs/authenticate/database-connections/custom-db/templates/delete)
* [Modèles de script pour la connexion](/fr-CA/docs/authenticate/database-connections/custom-db/templates/login)
* [Modèles de script pour la vérification](/fr-CA/docs/authenticate/database-connections/custom-db/templates/verify)
* [Modèle de script pour modifier le courriel](/fr-CA/docs/authenticate/database-connections/custom-db/templates/change-email)