> ## 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 Get User et modèles

> Le script Get User s’exécute lorsqu’Auth0 doit déterminer si un utilisateur existe ou non.

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

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

Lorsque **Import Users to Auth0** est activé, le script Get User s’exécute lorsqu’un utilisateur tente de s’inscrire afin de vérifier s’il existe déjà dans le magasin d’utilisateurs externe.

Le script Get User s’exécute également lorsqu’un utilisateur tente de :

* Modifier son adresse courriel (script [Change Email](/docs/fr-ca/authenticate/database-connections/custom-db/templates/change-email))
* Se connecter (script [Login](/docs/fr-ca/authenticate/database-connections/custom-db/templates/login))
* Modifier son mot de passe (script [Change Password](/docs/fr-ca/authenticate/database-connections/custom-db/templates/change-password))

Lorsque **Import Users to Auth0** est désactivé, le script Get User s’exécute lorsqu’un utilisateur tente de s’inscrire afin de vérifier s’il existe déjà dans le magasin d’utilisateurs externe. Si l’utilisateur existe déjà dans le magasin d’utilisateurs externe, le script Create ne s’exécute pas.

Le script Get User s’exécute également lorsqu’un utilisateur tente de :

* S’inscrire (script [Create](/docs/fr-ca/authenticate/database-connections/custom-db/templates/create))
* Modifier son adresse courriel (script [Change Email](/docs/fr-ca/authenticate/database-connections/custom-db/templates/change-email))
* Modifier ou réinitialiser son mot de passe (script [Change Password](/docs/fr-ca/authenticate/database-connections/custom-db/templates/change-password))

<div id="get-user-function">
  ## Fonction Get User
</div>

La fonction `getUser` doit :

* Envoyer l’identifiant de l’utilisateur à l’API de la base de données externe.
* Retourner les données du profil de l’utilisateur si celui-ci a été trouvé.
* Retourner une erreur s’il est impossible de déterminer si l’utilisateur existe ou non.

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

La fonction `getUser` accepte deux paramètres et renvoie une fonction `callback` :

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

| Paramètre  | Type     | Description                                                                   |
| ---------- | -------- | ----------------------------------------------------------------------------- |
| `email`    | String   | L'adresse courriel de l'utilisateur.                                          |
| `callback` | Fonction | Utilisé pour transmettre une erreur ou des données de profil dans le pipeline |

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

```javascript lines expandable theme={null}
function getUser(email, callback) {
  // Envoyer l'identifiant 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 callback 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 callback si l'utilisateur n'a pas été trouvé, retourner les données de profil dans le callback 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 `callback`
</div>

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

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

La fonction `callback` accepte jusqu’à deux paramètres et renvoie une fonction :

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

| Paramètre | Type  | Obligatoire | Description                                      |
| --------- | ----- | ----------- | ------------------------------------------------ |
| `error`   | Objet | Obligatoire | Contient les données d’erreur.                   |
| `profile` | Objet | Facultatif  | Contient les données de 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 être cohérentes avec celles renvoyées par le script Login.
</Warning>

Si l’utilisateur est trouvé, transmettez la valeur `null` au paramètre `error` et les données du profil de l’utilisateur au paramètre `profile`, sous [forme normalisée](/docs/fr-ca/manage-users/user-accounts/user-profiles/normalized-user-profile-schema) :

```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"
        }
      },
    ]
});
```

En plus des champs standard, vous pouvez inclure les champs `user_metadata`, `app_metadata` et `mfa_factors`.

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

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

```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 les renseignements pertinents sur la cause du problème :

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

Pour en savoir plus, consultez [Résoudre les problèmes liés aux bases de données personnalisées](/docs/fr-ca/authenticate/database-connections/custom-db/error-handling).

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

Auth0 fournit des scripts d’exemple pour les langages/technologies suivants :

<CodeGroup>
  ```javascript Javascript lines theme={null}
  function getByEmail(email, callback) {
    // Ce script doit récupérer le profil d’un utilisateur dans votre base de données existante,
    // sans authentifier l’utilisateur.
    // Il sert à vérifier si un utilisateur existe avant d’exécuter des flux ne nécessitant 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é. Le profil doit respecter le 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 connexion à 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));
  }
  ```

  ```javascript ASP.NET MVC3 lines expandable theme={null}
  // Pour ASP.NET Membership Provider (MVC3 - Universal Providers)
  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);
    });
  }
  ```

  ```javascript ASP.NET MVC4 lines expandable theme={null}
  // Pour ASP.NET Membership Provider (MVC4 - Simple Membership)
  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 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);
    });
  }
  ```

  ```javascript MongoDB 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
        });
      });
    });
  }
  ```

  ```javascript MySQL 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
      });
    });
  }
  ```

  ```javascript PostgreSQL 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
        });
      });
    });
  }
  ```

  ```javascript SQL Server 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);
    });
  }
  ```

  ```javascript Azure SQL Database 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);
  }
  ```

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

    let response;

    try {
      response = await axios.post(
        //stockez l’URL de l’API dans les paramètres de la connexion afin de 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, //mettez fin à l’appel de façon appropriée si la requête expire afin que le script puisse exécuter la fonction de rappel nécessaire
          headers: {
            //sécurise l’appel d’API avec la clé apiKey stockée dans les paramètres de la connexion.
            //approche simple et rapide, mais l’utilisation de jetons M2M est plus sécuritaire, car
            // un secret ne doit pas être partagé entre le client et l’API.
            "x-api-key": configuration.apiKey,
          },
        }
      );
    } catch (e) {
      if (e.response.status === 404) {
        //en supposant que l’API renvoie 404 lorsqu’aucun utilisateur correspondant à l’adresse courriel ou au nom d’utilisateur indiqué n’est trouvé
        return callback(null, null);
      }
      //fonction de 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 tenant, préfixez le
      //user_id avec une clé propre à la connexion, p. ex. : "connName|" + user.user_id
      //cela garantit des ID utilisateur uniques dans l’ensemble des 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));
    }
  }
  ```

  ```javascript Stormpath 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 le client ID et le Secret de votre 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 les champs additionnels que vous souhaitez reprendre de Stormpath
      });
    });
  }
  ```
</CodeGroup>