Scripts et modèles d’actions de base de données Get User

Le script Get User met en œuvre 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 vers Auth0; il peut également être requis sous certaines conditions lorsque la migration n’est pas activée, en fonction des opérations configurées pour la connexion. Auth0 recommande vivement que le user_id que vous renvoyez dans le profil utilisateur soit permanent et cohérent : pour un utilisateur donné, le script Get User doit renvoyer le même user_id à chaque exécution. Consultez Renvoyer un user_id cohérent pour plus de détails. Lorsque l’option Importer des utilisateurs vers Auth0 est activée, le script Get User s’exécute lorsqu’un utilisateur tente de s’inscrire, afin de vérifier si cet utilisateur 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)
Se connecter (script Login)
Modifier son mot de passe (script Change Password)

Lorsque l’option Importer des utilisateurs vers Auth0 est désactivée, le script Get User s’exécute lorsqu’un utilisateur tente de s’inscrire afin de vérifier s’il figure déjà dans le magasin d’utilisateurs externe. Si un utilisateur figure déjà dans ce magasin, le script Create n’est pas exécuté. Le script Get User s’exécute également lorsqu’un utilisateur tente de :

S’inscrire (script Create)
Modifier son adresse courriel (script Change Email)
Modifier ou réinitialiser son mot de passe (script Change Password)

Fonction Get User

La fonction getUser devrait :

Envoyer l’identificateur de l’utilisateur à l’API de la base de données externe.
Renvoyer les données de profil de l’utilisateur si celui-ci a été trouvé.
Renvoyer une erreur si un problème est survenu lors de la vérification de l’existence ou non de l’utilisateur.

Définition

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

getUser(email, callback): function

Paramètre	Type	Description
`email`	Chaîne	L’adresse courriel de l’utilisateur.
`callback`	Fonction	Permet de transmettre les erreurs ou les données de profil à travers la chaîne de traitement

Voici un exemple en pseudo-JavaScript illustrant comment vous pourriez implémenter la fonction getUser :

function getUser(email, callback) {
  // Envoyer l’identificateur de l’utilisateur à l’API de la base de données externe
  let options = {
    url: "https://example.com/api/search-users",
    body: {
      email: email
    }
  };

  send(options, (err, profileData) => {
    // Renvoyer une erreur dans la fonction de callback si la recherche de l’utilisateur a échoué
    if (err) {
      return callback(new Error(« Impossible de déterminer si l’utilisateur existe ou non. »));
    } else {
      // Renvoyer null dans la fonction de callback si l’utilisateur n’a pas été trouvé, renvoyer les données de profil dans la fonction de 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);
      }
    }
  });
}

Fonction de callback

La fonction de callback sert à transmettre les données du profil utilisateur ou les données d’erreur à travers la chaîne de traitement.

Définition

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

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 du profil utilisateur.

Renvoyer le profil utilisateur (utilisateur trouvé)

Les données de profil renvoyées par le script Get User pour un utilisateur doivent correspondre aux données de profil renvoyées par le script Login.

Si l’utilisateur est trouvé, transmettez une valeur null au paramètre error, puis transmettez les données de profil utilisateur au paramètre profile sous forme normalisée :

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.

Renvoyer un user_id cohérent

Auth0 utilise le user_id renvoyé par le script Get User pour identifier l’utilisateur au sein de votre locataire. Pour un utilisateur donné, cette valeur doit être cohérente : le script Get User doit renvoyer le même user_id à chaque fois qu’il est exécuté pour cet utilisateur. Déterminez l’user_id à partir d’une propriété stable et permanente de votre enregistrement source (telle que la clé primaire de la base de données), et non à partir d’une valeur susceptible de varier d’une exécution à l’autre.

Renvoyer un user_id incohérent peut entraîner la création d’utilisateurs en double ou orphelins, et peut perturber les flux qui reposent sur la stabilité de cet identificateur.

Obtenez l’user_id à partir d’une propriété stable de l’enregistrement source, de sorte que le même utilisateur corresponde toujours à la même valeur.

return callback(null, {
    // `user.id` est la clé primaire immuable de votre base de données
    user_id: "my-custom-db|" + user.id,
    email: user.email,
    email_verified: user.email_verified
});

Ne générez pas un user_id nouveau ou aléatoire à chaque appel. Par exemple, en renvoyant un UUID fraîchement généré. Cela produit un identificateur différent à chaque exécution du script pour un même utilisateur.

const { v4: uuidv4 } = require("uuid");

return callback(null, {
    // Anti-modèle : une nouvelle valeur est générée à chaque exécution, ce qu'Auth0 considère à chaque fois comme un nouveau utilisateur
    user_id: uuidv4(),
    email: user.email,
    email_verified: user.email_verified
});

Ne pas renvoyer de profil utilisateur (utilisateur introuvable)

Si l’utilisateur est introuvable, attribuez la valeur null au paramètre error et omettez le paramètre profile :

return callback(null);

Renvoyer une erreur

En cas d’erreur, transmettez les données d’erreur au paramètre error en y incluant les informations pertinentes sur la nature du problème :

return callback(new Error(« Mon message d’erreur personnalisé. »));

Pour plus d’informations, consultez Dépannage des connexions de bases de données personnalisées.

Exemples de scripts propres à chaque langue

Auth0 propose des exemples de scripts destinés à être utilisés avec les langues et les technologies suivantes :

function getByEmail(email, callback) {
  // Ce script doit récupérer un profil utilisateur à partir de 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).
  //
  // Il y a trois façons dont ce script peut se terminer :
  // 1. Un utilisateur a bien é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 tentative d’accès à votre base de données :
  //     callback(new Error("mon message d’erreur"));
  const msg = 'Please implement the Get User script for this database connection ' +
    'at https://manage.auth0.com/#/connections/database';
  return callback(new Error(msg));
}

// 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 // pour Windows Azure
    }
  });
  connection.on('debug', function(text) {
    // si vous rencontrez des problèmes de connexion, supprimez le commentaire de cette ligne pour obtenir des informations plus détaillées
    //console.log(text);
  }).on('errorMessage', function(text) {
    // cela affichera toute erreur 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);
    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);
  });
}

// 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 // 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) {
    // cela affichera toute erreur 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);
    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);
  });
}

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
      });
    });
  });
}

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
    });
  });
}

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 : toujours appeler `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
      });
    });
  });
}

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);
  });
}

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);
}

async function getUserAsync(email, callback) {
  //doit être mis à jour à mesure que de nouvelles versions d’axios sont publiées (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 de façon sécurisée si la requête expire, afin que le script puisse effectuer le rappel nécessaire
        headers: {
          //sécurisation de l’appel API avec une apiKey stockée dans les paramètres de connexion.
          //approche rapide et simple, cependant l’utilisation de jetons de communication entre machines est plus sécurisée, 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 un code 404 lorsqu’aucun utilisateur correspondant à l’adresse de courriel ou au nom d’utilisateur indiqué 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 personnalisées de base de données dans votre locataire, préfixez le
    //user_id avec une clé propre à la connexion, p. ex. : "connName|" + user.user_id
    //cela garantit des identifiants 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));
  }
}

function getByEmail(email, callback) {
  // Remplacer {yourStormpathClientId} par votre identifiant Stormpath
  var url = 'https://api.stormpath.com/v1/applications/{yourStormpathClientId}/accounts';
  // Ajouter votre identifiant client et votre secret d’API Stormpath
  var apiCredentials = {
    user : '{yourStormpathApiId}',
    password: '{yourStormpathApiSecret}'
  };
  // Effectuer 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
      // Ajouter tout champ supplémentaire que vous souhaitez transférer depuis Stormpath
    });
  });
}

Intégrer une connexion

Trouver des utilisateurs

Scripts et modèles d’actions de base de données Get User

Fonction Get User

Définition

Fonction de callback

Définition

Renvoyer le profil utilisateur (utilisateur trouvé)

Renvoyer un user_id cohérent

Ne pas renvoyer de profil utilisateur (utilisateur introuvable)

Renvoyer une erreur

Exemples de scripts propres à chaque langue

​Fonction Get User

​Définition

​Fonction de callback

​Définition

​Renvoyer le profil utilisateur (utilisateur trouvé)

​Renvoyer un user_id cohérent

​Ne pas renvoyer de profil utilisateur (utilisateur introuvable)

​Renvoyer une erreur

​Exemples de scripts propres à chaque langue

Fonction Get User

Définition

Fonction de callback

Définition

Renvoyer le profil utilisateur (utilisateur trouvé)

Renvoyer un user_id cohérent

Ne pas renvoyer de profil utilisateur (utilisateur introuvable)

Renvoyer une erreur

Exemples de scripts propres à chaque langue