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

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 et, lorsque la migration n’est pas activée, il peut être requis selon les opérations configurées pour la connexion. Auth0 recommande fortement que le user_id retourné dans le profil utilisateur soit permanent et cohérent : pour un utilisateur donné, le script Get User doit retourner le même user_id à chaque exécution. Consultez Retourner un user_id cohérent pour en savoir plus. 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)
Se connecter (script Login)
Modifier son mot de passe (script 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)
Modifier son adresse courriel (script Change Email)
Modifier ou réinitialiser son mot de passe (script Change Password)

Fonction Get User

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.

Définition

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

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 :

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

Fonction `callback`

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

Définition

La fonction 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 de profil de l’utilisateur.

Retourner le profil de l’utilisateur (utilisateur trouvé)

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.

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 :

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.

Retourner un user_id cohérent

Auth0 utilise le user_id retourné par le script Get User pour identifier l’utilisateur dans votre tenant. Pour un utilisateur donné, cette valeur doit être cohérente : le script Get User doit retourner le même user_id chaque fois qu’il s’exécute pour cet utilisateur. Générez le user_id à partir d’une propriété stable et permanente de l’enregistrement source (comme la clé primaire de la base de données), et non d’une valeur qui change d’une exécution à l’autre.

Retourner un user_id non cohérent peut créer des utilisateurs en double ou orphelins et interrompre les flows qui dépendent de la stabilité de l’identifiant.

Générez le user_id à partir d’une propriété stable de l’enregistrement source afin que le même utilisateur soit toujours mappé à 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 de user_id nouveau ou aléatoire à chaque requête. Par exemple, ne retournez pas un UUID nouvellement généré. Cela produit un identifiant différent chaque fois que le script s’exécute 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, et Auth0 la traite chaque fois comme un nouvel utilisateur
    user_id: uuidv4(),
    email: user.email,
    email_verified: user.email_verified
});

Ne retourner aucun profil utilisateur (utilisateur introuvable)

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

return callback(null);

Retourner une erreur

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 :

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.

Exemples de scripts par langage

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

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

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

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

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

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) {
  //à 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));
  }
}

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

Intégrer une connexion

Trouver des utilisateurs

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

Fonction Get User

Définition

Fonction `callback`

Définition

Retourner le profil de l’utilisateur (utilisateur trouvé)

Retourner un user_id cohérent

Ne retourner aucun profil utilisateur (utilisateur introuvable)

Retourner une erreur

Exemples de scripts par langage

​Fonction Get User

​Définition

​Fonction callback

​Définition

​Retourner le profil de l’utilisateur (utilisateur trouvé)

​Retourner un user_id cohérent

​Ne retourner aucun profil utilisateur (utilisateur introuvable)

​Retourner une erreur

​Exemples de scripts par langage

Fonction Get User

Définition

Fonction `callback`

Définition

Retourner le profil de l’utilisateur (utilisateur trouvé)

Retourner un user_id cohérent

Ne retourner aucun profil utilisateur (utilisateur introuvable)

Retourner une erreur

Exemples de scripts par langage