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

> Le script Verify s’exécute lorsqu’un utilisateur suit le lien dans le courriel de vérification d’Auth0.

Le script Verify implémente la fonction exécutée pour marquer l’état de vérification de l’adresse courriel d’un utilisateur dans une base de données externe. Nous recommandons de nommer cette fonction `verify`.

Ce script est utilisé uniquement dans les scénarios d’authentification héritée et est requis pour assurer le soutien de la vérification de l’adresse courriel de l’utilisateur. Une adresse courriel vérifiée est essentielle à un certain nombre de scénarios de flux de travail dans Auth0, et l’implémentation de ce script offrira ce soutien d’emblée.

S’il est activé, ce script est exécuté lorsqu’un utilisateur clique sur le lien contenu dans le courriel de vérification envoyé par Auth0.

<div id="verify-function">
  ## Fonction Verify
</div>

La fonction `verify` doit :

* Mettre à jour l’attribut `email_verified` (ou l’attribut équivalent) dans le profil de l’utilisateur stocké dans la base de données externe.
* Retourner `true` si l’action de mise à jour a réussi.
* Retourner une erreur si l’action de mise à jour a échoué.

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

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

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

| Paramètre  | Type     | Description                                                                  |
| ---------- | -------- | ---------------------------------------------------------------------------- |
| `email`    | String   | Adresse courriel de l'utilisateur.                                           |
| `callback` | Function | Utilisé pour transmettre l'erreur ou les données de profil dans le pipeline. |

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

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

  send(options, (err) => {
    // Retourner une erreur dans le callback si la mise à jour a échoué
    if (err) {
      return callback(new Error(email, "My custom error message."));
    } else {
      // Retourner true dans le callback si la mise à jour a réussi
      return callback(null, true);
    }
  });
}
```

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

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

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

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

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

| Paramètre  | Type    | Obligatoire | Description                                                                                                                                                               |
| ---------- | ------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `error`    | objet   | Obligatoire | Contient les données d’erreur.                                                                                                                                            |
| `verified` | Boolean | Facultatif  | Contient une valeur indiquant l’état de vérification de l’utilisateur dans la base de données externe (`true` ou `false`). Obligatoire seulement si la valeur est `true`. |

<div id="return-a-success">
  ### Renvoyer un succès
</div>

Si l’état de vérification de l'utilisateur a été mis à jour avec succès dans la base de données externe, passez la valeur `null` pour le paramètre `error` et la valeur `true` pour le paramètre `verified` :

```js theme={null}
callback(null, true);
```

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Le script Verify ne modifie pas la valeur de l'attribut `email_verified` dans le profil Auth0 de l'utilisateur, quelle que soit la valeur renvoyée dans la fonction `callback`.

  Pour mettre à jour l'attribut `email_verified` dans le profil Auth0 de l'utilisateur, vous devez inclure l'attribut `email_verified` et sa valeur dans l'objet de profil de l'utilisateur renvoyé par les scripts [Login](/docs/fr-ca/authenticate/database-connections/custom-db/templates/login) et [Get User](/docs/fr-ca/authenticate/database-connections/custom-db/templates/get-user).
</Callout>

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

Si une erreur se produit, le paramètre `error` doit contenir des renseignements pertinents sur la nature du problème :

```js 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 scripts d’exemple pour les langages et technologies suivants :

<CodeGroup>
  ```javascript JavaScript lines theme={null}
  function verify(email, callback) {
    // Ce script doit marquer l'adresse courriel de l'utilisateur actuel comme
    // vérifiée dans votre base de données.
    // Il est exécuté chaque fois qu'un utilisateur clique sur le lien de vérification envoyé par courriel.
    // Ces courriels peuvent être personnalisés à l'adresse https://manage.auth0.com/#/emails.
    // Vous pouvez présumer sans risque que l'adresse courriel de l'utilisateur existe déjà dans votre base de données,
    // car les courriels de vérification, s'ils sont activés, sont envoyés immédiatement après une
    // inscription réussie.
    //
    // Ce script peut se terminer de deux façons :
    // 1. L'adresse courriel de l'utilisateur a été vérifiée avec succès
    //     callback(null, true);
    // 2. Un problème est survenu lors de la tentative d'accès à votre base de données :
    //     callback(new Error("my error message"));
    //
    // Si une erreur est retournée, elle sera transmise à la chaîne de requête de la page
    // vers laquelle l'utilisateur est redirigé après avoir cliqué sur le lien de vérification.
    // Par exemple, retourner `callback(new Error("error"))` et rediriger vers
    // https://example.com redirigerait vers l'URL suivante :
    //     https://example.com?email=alice%40example.com&message=error&success=false
    const msg = 'Veuillez implémenter le script Verify pour cette connexion de base de données ' +
      'à l\'adresse 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 verify(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,
        // 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);
      verifyMembershipUser(email, function(err, wasUpdated) {
        if (err) return callback(err); // ceci retournera un 500
        callback(null, wasUpdated);
      });
    });
    function verifyMembershipUser(email, callback) {
      // le champ isApproved est l'indicateur de vérification de courriel
      const updateMembership =
        'UPDATE Memberships SET isApproved = \'true\' ' +
        'WHERE isApproved = \'false\' AND Email = @Email';
      const updateMembershipQuery = new Request(updateMembership, function(err, rowCount) {
        if (err) {
          return callback(err);
        }
        callback(null, rowCount > 0);
      });
      updateMembershipQuery.addParameter('Email', TYPES.VarChar, email);
      connection.execSql(updateMembershipQuery);
    }
  }
  ```

  ```javascript ASP.NET MVC4 lines expandable theme={null}
  // Pour ASP.NET Membership Provider (MVC4 - Simple Membership)
  function verify (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,
        // 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);
      verifyMembershipUser(email, function(err, wasUpdated) {
        if (err) return callback(err); // ceci retournera un 500
        callback(null, wasUpdated);
      });
    });
    function findUserId(email, callback) {
      const findUserIdFromEmail =
        'SELECT UserProfile.UserId FROM ' +
        'UserProfile INNER JOIN webpages_Membership ' +
        'ON UserProfile.UserId = webpages_Membership.UserId ' +
        'WHERE UserName = @Username';
      const findUserIdFromEmailQuery = new Request(findUserIdFromEmail, function (err, rowCount, rows) {
        if (err || rowCount < 1) return callback(err);
        const userId = rows[0][0].value;
        callback(null, userId);
      });
      findUserIdFromEmailQuery.addParameter('Username', TYPES.VarChar, email);
      connection.execSql(findUserIdFromEmailQuery);
    }
    function verifyMembershipUser(email, callback) {
      findUserId(email, function (err, userId) {
        if (err || !userId) return callback(err);
        // le champ isConfirmed est l'indicateur de vérification de courriel
        const updateMembership =
          'UPDATE webpages_Membership SET isConfirmed = \'true\' ' +
          'WHERE isConfirmed = \'false\' AND UserId = @UserId';
        const updateMembershipQuery = new Request(updateMembership, function (err, rowCount) {
          return callback(err, rowCount > 0);
        });
        updateMembershipQuery.addParameter('UserId', TYPES.VarChar, userId);
        connection.execSql(updateMembershipQuery);
      });
    }
  }
  ```

  ```javascript MongoDB lines theme={null}
  function verify (email, 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');
      const query = { email: email, email_verified: false };
      users.update(query, { $set: { email_verified: true } }, function (err, count) {
        client.close();
        if (err) return callback(err);
        callback(null, count > 0);
      });
    });
  }
  ```

  ```javascript MySQL lines theme={null}
  function verify(email, callback) {
    const mysql = require('mysql');
    const connection = mysql({
      host: 'localhost',
      user: 'me',
      password: 'secret',
      database: 'mydb'
    });
    connection.connect();
    const query = 'UPDATE users SET email_Verified = true WHERE email_Verified = false AND email = ?';
    connection.query(query, [ email ], function(err, results) {
      if (err) return callback(err);
      callback(null, results.length > 0);
    });
  }
  ```

  ```javascript PostgreSQL lines theme={null}
  function verify (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 = 'UPDATE users SET email_Verified = true WHERE email_Verified = false AND email = $1';
      client.query(query, [email], function (err, result) {
        // REMARQUE : appelez toujours `done()` ici pour fermer
        // la connexion à la base de données
        done();
        return callback(err, result && result.rowCount > 0);
      });
    });
  }
  ```

  ```javascript SQL Server lines expandable theme={null}
  function verify (email, callback) {
    //cet exemple utilise la bibliothèque « tedious »
    //plus d’information 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 = 'UPDATE dbo.Users SET Email_Verified = true WHERE Email_Verified = false AND 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, rows) {
        if (err) return callback(err);
        callback(null, rows > 0);
      });
      request.addParameter('Email', TYPES.VarChar, email);
      connection.execSql(request);
    });
  }
  ```

  ```javascript Azure SQL Database lines expandable theme={null}
  function verify (email, callback) {
    //cet exemple utilise la bibliothèque « tedious »
    //pour en savoir plus : 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
      }
    });
    var query =
      'UPDATE Users SET Email_Verified=\'TRUE\' ' +
      'WHERE Email_Verified=\'FALSE\' AND Email=@Email';
    connection.on('debug', function(text) {
      // Décommentez la ligne suivante pour activer les messages de débogage
      // console.log(text);
    }).on('errorMessage', function(text) {
      console.log(JSON.stringify(text, null, 2));
    }).on('infoMessage', function(text) {
      // Décommentez la ligne suivante pour activer les messages d’information
      // console.log(JSON.stringify(text, null, 2));
    });
    connection.on('connect', function (err) {
      if (err) { return callback(err); }
      var request = new Request(query, function (err, rows) {
        if (err) { return callback(err); }
        console.log('rows: ' + rows);
        callback(null, rows > 0);
      });
      request.addParameter('Email', TYPES.VarChar, email);
      connection.execSql(request);
    });
  }
  ```
</CodeGroup>