Vincula varios proveedores de autenticación con una cuenta mediante JavaScript

Para permitir que los usuarios accedan a la app con varios proveedores de autenticación, puedes vincular las credenciales de estos proveedores con una cuenta de usuario existente. Los usuarios se pueden identificar con el mismo ID de usuario de Firebase, sin importar el proveedor de autenticación que hayan usado para acceder. Por ejemplo, un usuario que accedió con una contraseña puede vincular una Cuenta de Google y después usar cualquiera de los dos métodos para acceder. Por otra parte, un usuario anónimo puede vincular una cuenta de Facebook y luego acceder con Facebook para continuar usando la app.

Antes de comenzar

Agrega compatibilidad para dos o más proveedores de autenticación (posiblemente con la inclusión de la autenticación anónima) a tu app.

Para vincular credenciales de un proveedor de autenticación como Google o Facebook con una cuenta de usuario existente, haz lo siguiente:

  1. El usuario debe acceder con cualquier proveedor o método de autenticación.
  2. Obtén el objeto AuthProvider que corresponde al proveedor que deseas vincular con la cuenta del usuario. Ejemplos: 
    var googleProvider = new firebase.auth.GoogleAuthProvider();
var facebookProvider = new firebase.auth.FacebookAuthProvider();
var twitterProvider = new firebase.auth.TwitterAuthProvider();
var githubProvider = new firebase.auth.GithubAuthProvider();
    link-multiple-accounts.js
  3. Solicita al usuario que acceda con el proveedor que deseas vincular. Para pedir a tus usuarios que accedan, puedes mostrar una ventana emergente o redireccionarlos a la página de acceso del proveedor. En dispositivos móviles, se prefiere el método de redireccionamiento.
    • Para acceder con una ventana emergente, llama a linkWithPopup:
      auth.currentUser.linkWithPopup(provider).then(function(result) {
  // Accounts successfully linked.
  var credential = result.credential;
  var user = result.user;
  // ...
}).catch(function(error) {
  // Handle Errors here.
  // ...
});
      link-multiple-accounts.js
    • Para acceder mediante el redireccionamiento a la página de acceso del proveedor, llama a linkWithRedirect:
      auth.currentUser.linkWithRedirect(provider)
  .then(/* ... */)
  .catch(/* ... */);
      link-multiple-accounts.js
      Después de que el usuario accede, se lo redirecciona de vuelta a tu página. Luego, para recuperar el resultado del acceso, puedes llamar a getRedirectResult cuando tu página cargue el siguiente código: 
      auth.getRedirectResult().then(function(result) {
  if (result.credential) {
    // Accounts successfully linked.
    var credential = result.credential;
    var user = result.user;
    // ...
  }
}).catch(function(error) {
  // Handle Errors here.
  // ...
});
      link-multiple-accounts.js
    Si el usuario accede correctamente, la cuenta del usuario correspondiente al proveedor se vincula con la cuenta del usuario en el proyecto de Firebase.

    La vinculación de cuentas fallará si ya se vincularon las credenciales con la cuenta de otro usuario. En esta situación, debes administrar la fusión de las cuentas y los datos asociados según corresponda para tu app:

    // The implementation of how you store your user data depends on your application
var repo = new MyUserDataRepo();

// Get reference to the currently signed-in user
var prevUser = auth.currentUser;

// Get the data which you will want to merge. This should be done now
// while the app is still signed in as this user.
var prevUserData = repo.get(prevUser);

// Delete the user's data now, we will restore it if the merge fails
repo.delete(prevUser);

// Sign in user with the account you want to link to
auth.signInWithCredential(newCredential).then(function(result) {
  console.log("Sign In Success", result);
  var currentUser = result.user;
  var currentUserData = repo.get(currentUser);

  // Merge prevUser and currentUser data stored in Firebase.
  // Note: How you handle this is specific to your application
  var mergedData = repo.merge(prevUserData, currentUserData);

  return prevUser.linkWithCredential(result.credential)
    .then(function(linkResult) {
      // Sign in with the newly linked credential
      return auth.signInWithCredential(linkResult.credential);
    })
    .then(function(signInResult) {
      // Save the merged data to the new user
      repo.set(signInResult.user, mergedData);
    });
}).catch(function(error) {
  // If there are errors we want to undo the data merge/deletion
  console.log("Sign In Error", error);
  repo.set(prevUser, prevUserData);
  repo.set(currentUser, currentUserData);
});
    link-multiple-accounts.js

Para agregar credenciales de dirección de correo electrónico y contraseña a una cuenta de usuario existente, haz lo siguiente:

  1. El usuario debe acceder con cualquier proveedor o método de autenticación.
  2. Pide al usuario que ingrese una dirección de correo electrónico y una contraseña nueva.
  3. Crea un objeto AuthCredential con la dirección de correo electrónico y la contraseña:
    var credential = firebase.auth.EmailAuthProvider.credential(email, password);
    link-multiple-accounts.js

  4. Pasa el objeto AuthCredential al método linkWithCredential del usuario que accedió:

    auth.currentUser.linkWithCredential(credential)
  .then(function(usercred) {
    var user = usercred.user;
    console.log("Account linking success", user);
  }).catch(function(error) {
    console.log("Account linking error", error);
  });
    link-multiple-accounts.js

    La llamada a linkWithCredential fallará si ya se vincularon las credenciales con la cuenta de otro usuario. En esta situación, debes administrar la fusión de las cuentas y los datos asociados según corresponda para la app (consulta los siguientes ejemplos).

Puedes desvincular un proveedor de autenticación de una cuenta para que el usuario ya no pueda acceder con ese proveedor.

Para desvincular un proveedor de autenticación de una cuenta de usuario, pasa el ID del proveedor al método unlink. Puedes obtener los ID de los proveedores de autenticación vinculados con un usuario desde la propiedad providerData.

user.unlink(providerId).then(function() {
  // Auth provider unlinked from account
  // ...
}).catch(function(error) {
  // An error happened
  // ...
});
link-multiple-accounts.js