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

Le script Create implémente la fonction définie lorsqu’un utilisateur est créé. Nous vous recommandons de nommer cette fonction create. Ce script est facultatif. S’il est activé, lorsqu’un utilisateur s’inscrit au moyen de ou est créé au moyen du ou de l’Auth0 , Auth0 exécute le script pour créer l’enregistrement utilisateur correspondant dans la base de données externe. Lorsqu’un utilisateur est créé dans Auth0, Auth0 appelle une série de scripts :

Get User : vérifie que l’utilisateur n’existe pas déjà dans Auth0 ou dans la base de données externe.
Create : crée l’utilisateur dans la base de données externe.
Login : vérifie que l’utilisateur a bien été créé.

Fonction Create

La fonction create doit :

Envoyer les données de profil de l’utilisateur à l’API de la base de données externe.
Renvoyer une erreur si l’opération de création de l’utilisateur a échoué.

Définition

La fonction create accepte deux paramètres et renvoie une fonction de rappel callback :

create(user, callback): function

Paramètre	Description
`user`	Objet. Contient les données du profil utilisateur provenant du processus de création de l’utilisateur.
`callback`	Fonction. Utilisée pour transmettre les données d’erreur dans le pipeline.

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

function create(user, callback) {
  // Envoyer les données du profil utilisateur à l'API de base de données externe
  let hashedPassword = hash(user.password);

  let options = {
    url: "https://example.com/api/create",
    body: {
      email: user.email,
      username: user.username,
      password: hashedPassword
    }
  };

  send(options, err => {
    // Retourner une erreur dans le callback si l'utilisateur existe déjà
    if (err && err.id === "USER_ALREADY_EXISTS") {
      return callback(new ValidationError("user_exists", "My custom error message."));
    } else if (err) {
      // Retourner une erreur dans le callback si une erreur s'est produite
      return callback(new Error("My custom error message."));
    }

    // Retourner la valeur `null` dans le callback si l'opération de création de l'utilisateur a réussi
    return callback(null);
  });
}

Chiffrement

Hachez la valeur du mot de passe à l’aide d’une bibliothèque de hachage cryptographique comme bcrypt afin d’éviter toute fuite de données potentielle. Évitez de consigner, de stocker ou de transmettre le mot de passe sous une forme non chiffrée. Par exemple :

bcrypt.hash(password, 10, function (err, hash) {
    if (err) {
        return callback(err);
    } else {
        // Retourner le mot de passe haché
    }
});

Fonction de rappel

La fonction callback prend un paramètre et retourne une fonction.

Définition

callback(error): function

Paramètre	Type	Obligatoire	Description
`error`	Objet	Obligatoire	Contient des données d’erreur.

Objet de type ValidationError

L’objet de type d’erreur personnalisé ValidationError vous permet de transmettre des données qui seront affichées dans vos journaux du tenant. Le constructeur ValidationError accepte jusqu’à deux paramètres :

new ValidationError(errorCode[, message]): ValidationError

Paramètre	Description
`errorCode`	(Obligatoire) String. Indique le type d’erreur.
`message`	(Facultatif) String. Contient des informations sur l’erreur.

Renvoyer une réussite

Si la création de l’utilisateur a réussi, appelez la fonction de rappel callback et transmettez la valeur null au paramètre error :

return callback(null);

Renvoyer une erreur

Si une erreur survient, appelez la fonction de rappel et transmettez-lui les renseignements pertinents sur l’erreur dans le paramètre error. Par exemple, vous pouvez renvoyer une erreur avec la valeur user_exists pour le paramètre errorCode :

return callback(new ValidationError("user_exists", "My custom error message."));

Si vous le faites, Auth0 enregistre un événement de journal fs du tenant.

Champ de l’événement du journal du tenant	Valeur
Code	`fs`
Événement	Échec de l’inscription
Description	`Mon message d’erreur personnalisé.`

Paramètre de l’objet `user`

Le paramètre d’objet user contient un ensemble prédéfini de propriétés issues du processus de création de l’utilisateur :

Propriété	Description
`client_id`	L’ID client de l’application Auth0 si l’utilisateur s’est inscrit par l’entremise de Universal Login, ou la clé API si l’utilisateur a été créé au moyen de l’Auth0 Dashboard ou de la Management API.
`tenant`	Le nom du tenant Auth0.
`email`	L’adresse courriel de l’utilisateur.
`password`	Le mot de passe de l’utilisateur en texte brut.
`username`	Le nom d’utilisateur. Obligatoire seulement si le paramètre Requires Username est activé pour la connexion de base de données personnalisée.
`connection`	Le nom de la connexion Auth0.
`user_metadata`	Contient les propriétés de l’objet `user_metadata` dans le profil Auth0 de l’utilisateur, si cet objet existe.
`app_metadata`	Contient les propriétés de l’objet `app_metadata` dans le profil Auth0 de l’utilisateur, si cet objet existe.

Propriété `username`

Si le paramètre Requires Username est activé pour votre connexion de base de données personnalisée, les scripts Login et Get User doivent prendre en charge la propriété username ; vous devriez donc l’enregistrer dans votre base de données externe.

Métadonnées utilisateur et d’application

Les propriétés user_metadata et app_metadata n’ont pas besoin d’être stockées dans votre base de données externe. Auth0 stocke automatiquement ces valeurs dans l’enregistrement de profil utilisateur créé en interne. Si vous créez et utilisez des champs personnalisés lors de l’inscription, ils seront inclus dans l’objet user. Par exemple :

{
    client_id: "8tkMo6n1QkKOazqPcSQd8wU7LzXYibgK",
    tenant: "{yourAuth0Tenant}",
    email: "username@domain.com",
    password: "mySuperSecretPassword123",
    username: "username456",
    user_metadata: {
        "language": "en"
    },
    app_metadata: {
        "plan": "full"
    }
}

Exemples de scripts par langage

Auth0 fournit des exemples de scripts pour les langages/technologies suivants :

function create(user, callback) {
  // Ce script doit créer une entrée utilisateur dans votre base de données existante. Il sera
  // exécuté lorsqu'un utilisateur tente de s'inscrire ou lorsqu'un utilisateur est créé
  // via le tableau de bord Auth0 ou l'API Management.
  // Une fois ce script terminé, le script Login sera
  // exécuté immédiatement après, afin de vérifier que l'utilisateur a été créé
  // avec succès.
  //
  // L'objet user contiendra toujours les propriétés suivantes :
  // * email : le courriel de l'utilisateur
  // * password : le mot de passe saisi par l'utilisateur, en clair
  // * tenant : le nom de ce compte Auth0
  // * client_id : l'identifiant client de l'application où l'utilisateur s'est inscrit, ou
  //               la clé API si créé via l'API Management ou le tableau de bord Auth0
  // * connection : le nom de cette connexion de base de données
  //
  // Ce script peut se terminer de trois façons :
  // 1. Un utilisateur a été créé avec succès
  //     callback(null);
  // 2. Cet utilisateur existe déjà dans votre base de données
  //     callback(new ValidationError("user_exists", "my error message"));
  // 3. Une erreur est survenue lors de la tentative d'accès à votre base de données
  //     callback(new Error("my error message"));
  const msg = 'Please implement the Create 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 create(user, callback) {
  const crypto = require('crypto');
  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,
      // Required to retrieve userId needed for Membership entity creation
      rowCollectionOnRequestCompletion: true
    }
  });
  const applicationId = 'your-application-id-goes-here';
  /**
   * hashPassword
   *
   * This function creates a hashed version of the password to store in the database.
   *
   * @password  {[string]}      the password entered by the user
   * @return    {[string]}      the hashed password
   */
  function hashPassword(password, salt) {
    // the default implementation uses HMACSHA256 and since Key length is 64
    // and default salt is 16 bytes, Membership will fill the buffer repeating the salt
    const key = Buffer.concat([salt, salt, salt, salt]);
    const hmac = crypto.createHmac('sha256', key);
    hmac.update(Buffer.from(password, 'ucs2'));
    return hmac.digest('base64');
  }
  connection.on('debug', function(text) {
    // if you have connection issues, uncomment this to get more detailed info
    // console.log(text);
  }).on('errorMessage', function(text) {
    // this will show any errors when connecting to the SQL database or with the SQL statements
    console.log(JSON.stringify(text));
  });
  connection.on('connect', function(err) {
    if (err) {
      return callback(err);
    }
    createMembershipUser(user, function(err, user) {
      if (err) return callback(err); // this will return a 500
      if (!user) return callback(); // this will return a 401
      callback(null, user);
    });
  });
  function createMembershipUser(user, callback) {
    const userData = {
      UserName: user.email,
      ApplicationId: applicationId
    };
    const createUser =
      'INSERT INTO Users (UserName, LastActivityDate, ApplicationId, UserId, IsAnonymous) ' +
      'OUTPUT Inserted.UserId ' +
      'VALUES (@UserName, GETDATE(), @ApplicationId, NEWID(), \'false\')';
    const createUserQuery = new Request(createUser, function(err, rowCount, rows) {
      if (err) return callback(err);
      // No records added
      if (rowCount === 0) return callback(null);
      const userId = rows[0][0].value;
      const salt = crypto.randomBytes(16);
      const membershipData = {
        ApplicationId: applicationId,
        Email: user.email,
        Password: hashPassword(user.password, salt),
        PasswordSalt: salt.toString('base64'),
        UserId: userId
      };
      const createMembership =
        'INSERT INTO Memberships (ApplicationId, UserId, Password, PasswordFormat, ' +
        'PasswordSalt, Email, isApproved, isLockedOut, CreateDate, LastLoginDate, ' +
        'LastPasswordChangedDate, LastLockoutDate, FailedPasswordAttemptCount, ' +
        'FailedPasswordAttemptWindowStart, FailedPasswordAnswerAttemptCount, ' +
        'FailedPasswordAnswerAttemptWindowsStart) ' +
        'VALUES ' +
        '(@ApplicationId, @UserId, @Password, 1, @PasswordSalt, ' +
        '@Email, \'false\', \'false\', GETDATE(), GETDATE(), GETDATE(), GETDATE(), 0, 0, 0, 0)';
      const createMembershipQuery = new Request(createMembership, function(err, rowCount) {
        if (err) return callback(err);
        if (rowCount === 0) return callback(null);
        callback(null, rowCount > 0);
      });
      createMembershipQuery.addParameter('ApplicationId', TYPES.VarChar, membershipData.ApplicationId);
      createMembershipQuery.addParameter('Email', TYPES.VarChar, membershipData.Email);
      createMembershipQuery.addParameter('Password', TYPES.VarChar, membershipData.Password);
      createMembershipQuery.addParameter('PasswordSalt', TYPES.VarChar, membershipData.PasswordSalt);
      createMembershipQuery.addParameter('UserId', TYPES.VarChar, membershipData.UserId);
      connection.execSql(createMembershipQuery);
    });
    createUserQuery.addParameter('UserName', TYPES.VarChar, userData.UserName);
    createUserQuery.addParameter('ApplicationId', TYPES.VarChar, userData.ApplicationId);
    connection.execSql(createUserQuery);
  }
}

// Pour ASP.NET Membership Provider (MVC4 - Simple Membership)
function create(user, callback) {
  const crypto = require('crypto');
  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,
      // Required to retrieve userId needed for Membership entity creation
      rowCollectionOnRequestCompletion: true
    }
  });
  /**
   * hashPassword
   *
   * Cette fonction hache un mot de passe à l’aide de l’algorithme HMAC SHA256.
   *
   * @password    {[string]}    mot de passe à hacher
   * @salt        {[string]}    salt à utiliser dans le processus de hachage
   * @callback    {[function]}  callback à appeler après le hachage du mot de passe
   */
  function hashPassword(password, salt, callback) {
    const iterations = 1000;
    const passwordHashLength = 32;
    crypto.pbkdf2(password, salt, iterations, passwordHashLength, 'sha1', function (err, hashed) {
      if (err) return callback(err);
      const result = Buffer.concat([Buffer.from([0], 1), salt, Buffer.from(hashed, 'binary')]);
      const resultBase64 = result.toString('base64');
      callback(null, resultBase64);
    });
  }
  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);
    const createUser =
      'INSERT INTO UserProfile (UserName) ' +
      'OUTPUT Inserted.UserId ' +
      'VALUES (@UserName)';
    const createUserQuery = new Request(createUser, function (err, rowCount, rows) {
      if (err || rowCount === 0) return callback(err);
      const userId = rows[0][0].value;
      const salt = crypto.randomBytes(16);
      const createMembership =
        'INSERT INTO webpages_Membership ' +
        '(UserId, CreateDate, IsConfirmed, PasswordFailuresSinceLastSuccess, Password, PasswordSalt) ' +
        'VALUES ' +
        '(@UserId, GETDATE(), \'false\', 0, @Password, \'\')';
      const createMembershipQuery = new Request(createMembership, function (err, rowCount) {
        if (err || rowCount === 0) return callback(err);
        callback(null, rowCount > 0);
      });
      hashPassword(user.password, salt, function (err, hashedPassword) {
        if (err) return callback(err);
        createMembershipQuery.addParameter('Password', TYPES.VarChar, hashedPassword);
        createMembershipQuery.addParameter('PasswordSalt', TYPES.VarChar, salt.toString('base64'));
        createMembershipQuery.addParameter('UserId', TYPES.VarChar, userId);
        connection.execSql(createMembershipQuery);
      });
    });
    createUserQuery.addParameter('UserName', TYPES.VarChar, user.email);
    connection.execSql(createUserQuery);
  });
}

function create(user, callback) {
  const bcrypt = require('bcrypt');
  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');
    users.findOne({ email: user.email }, function (err, withSameMail) {
      if (err || withSameMail) {
        client.close();
        return callback(err || new Error('the user already exists'));
      }
      bcrypt.hash(user.password, 10, function (err, hash) {
        if (err) {
          client.close();
          return callback(err);
        }
        user.password = hash;
        users.insert(user, function (err, inserted) {
          client.close();
          if (err) return callback(err);
          callback(null);
        });
      });
    });
  });
}

function create(user, callback) {
  const mysql = require('mysql');
  const bcrypt = require('bcrypt');
  const connection = mysql({
    host: 'localhost',
    user: 'me',
    password: 'secret',
    database: 'mydb'
  });
  connection.connect();
  const query = 'INSERT INTO users SET ?';
  bcrypt.hash(user.password, 10, function(err, hash) {
    if (err) return callback(err);
    const insert = {
      password: hash,
      email: user.email
    };
    connection.query(query, insert, function(err, results) {
      if (err) return callback(err);
      if (results.length === 0) return callback();
      callback(null);
    });
  });
}

function create(user, callback) {
  //cet exemple utilise la bibliothèque « pg »
  //pour en savoir plus : https://github.com/brianc/node-postgres
  const bcrypt = require('bcrypt');
  const postgres = require('pg');
  const conString = 'postgres://user:pass@localhost/mydb';
  postgres.connect(conString, function (err, client, done) {
    if (err) return callback(err);
    bcrypt.hash(user.password, 10, function (err, hashedPassword) {
      if (err) return callback(err);
      const query = 'INSERT INTO users(email, password) VALUES ($1, $2)';
      client.query(query, [user.email, hashedPassword], function (err, result) {
        // REMARQUE : appelez toujours `done()` ici pour fermer
        // la connexion à la base de données
        done();
        return callback(err);
      });
    });
  });
}

function create(user, callback) {
  //cet exemple utilise la bibliothèque « tedious »
  //plus d’information ici : http://pekim.github.io/tedious/index.html
  const bcrypt = require('bcrypt');
  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 = 'INSERT INTO dbo.Users SET Email = @Email, Password = @Password';
  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);
    });
    bcrypt.hash(user.password, 10, function(err, hash) {
      if (err) return callback(err);
      request.addParameter('Email', TYPES.VarChar, user.email);
      request.addParameter('Password', TYPES.VarChar, hash);
      connection.execSql(request);
    });
  });
}

function create (user, callback) {
  //cet exemple utilise la bibliothèque « tedious »
  //plus d’informations ici : 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 bcrypt = require('bcrypt');
  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 = "INSERT INTO users (Email, Password) VALUES (@Email, @Password)";
  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);
    });
    bcrypt.hash(user.password, 10, function (err, hashedPassword) {
      if (err) { return callback(err); }
      request.addParameter('Email', TYPES.VarChar, user.email);
      request.addParameter('Password', TYPES.VarChar, hashedPassword);
      connection.execSql(request);
    });
  });
}

function create(user, callback) {
  const request = require('request');
  request.post({
    url: 'https://myserviceurl.com/users',
    json: user
    //pour plus d’options, consultez :
    //https://github.com/mikeal/request#requestoptions-callback
  }, function(err, response, body) {
    if (err) return callback(err);
    callback(null);
  });
}

Résolution des problèmes

Si vous ne parvenez pas à créer un utilisateur dans votre référentiel d’utilisateurs externe ou dans Auth0 :

Vérifiez les instructions console.log() dans les journaux en temps réel d’Actions.
Repérez l’utilisateur dans votre ancienne base de données et supprimez-le au besoin. Si l’état partiel de l’utilisateur se trouve dans Auth0, utilisez le point de terminaison Supprimer un utilisateur ou le point de terminaison Supprimer un utilisateur d’une connexion de la Management API.
Assurez-vous que le mode d’importation est désactivé, puis configurez le script Create.

Add Login

Provision Users

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

Fonction Create

Définition

Chiffrement

Fonction de rappel

Définition

Objet de type ValidationError

Renvoyer une réussite

Renvoyer une erreur

Paramètre de l’objet `user`

Propriété `username`

Métadonnées utilisateur et d’application

Exemples de scripts par langage

Résolution des problèmes

​Fonction Create

​Définition

​Chiffrement

​Fonction de rappel

​Définition

​Objet de type ValidationError

​Renvoyer une réussite

​Renvoyer une erreur

​Paramètre de l’objet user

​Propriété username

​Métadonnées utilisateur et d’application

​Champs personnalisés d’inscription

​Exemples de scripts par langage

​Résolution des problèmes

Fonction Create

Définition

Chiffrement

Fonction de rappel

Définition

Objet de type ValidationError

Renvoyer une réussite

Renvoyer une erreur

Paramètre de l’objet `user`

Propriété `username`

Métadonnées utilisateur et d’application

Champs personnalisés d’inscription

Exemples de scripts par langage

Résolution des problèmes