Firebase chasse l'utilisateur actuel
J'ai donc ce problème où chaque fois que j'ajoute un nouveau compte utilisateur, il renvoie l'utilisateur actuel déjà connecté. J'ai lu l'API firebase et il a déclaré que " Si le nouveau compte a été créé, l'utilisateur est connecté automatiquement "Mais ils n'ont jamais dit autre chose pour éviter cela.
//ADD EMPLOYEES
addEmployees: function(formData){
firebase.auth().createUserWithEmailAndPassword(formData.email, formData.password).then(function(data){
console.log(data);
});
},
Je suis l'administrateur et j'ajoute des comptes sur mon site. Je voudrais que je puisse ajouter un compte sans être déconnecté et connecté au nouveau compte. De toute façon je peux éviter ça?
Mise à jour 20161110 - réponse originale ci-dessous
Consultez également cette réponse pour une approche différente.
Réponse originale
C'est réellement possible.
Mais pas directement, le moyen de le faire est de créer une deuxième référence d’authentification et de l’utiliser pour créer des utilisateurs:
var config = {apiKey: "apiKey",
authDomain: "projectId.firebaseapp.com",
databaseURL: "https://databaseName.firebaseio.com"};
var secondaryApp = firebase.initializeApp(config, "Secondary");
secondaryApp.auth().createUserWithEmailAndPassword(em, pwd).then(function(firebaseUser) {
console.log("User " + firebaseUser.uid + " created successfully!");
//I don't know if the next statement is necessary
secondaryApp.auth().signOut();
});
Si vous ne spécifiez pas la connexion firebase que vous utilisez pour une opération, elle utilisera la première par défaut.
Source pour plusieurs références d'application.
MODIFIER
Pour la création d'un nouvel utilisateur, peu importe qu'il n'y ait personne ou quelqu'un d'autre que l'administrateur authentifié sur la deuxième référence d'authentification, car pour créer un compte, il vous suffit de disposer de la référence d'authentification elle-même.
Ce qui suit n’a pas été testé, mais c’est quelque chose à penser
La chose à laquelle vous devez penser est l’écriture de données sur firebase. La pratique courante est que les utilisateurs peuvent modifier/mettre à jour leurs propres informations utilisateur. Ainsi, lorsque vous utilisez la deuxième référence d'authentification pour l'écrire, cela devrait fonctionner. Mais si vous avez quelque chose comme des rôles ou des autorisations pour cet utilisateur, assurez-vous de l'écrire avec la référence auth qui dispose des autorisations appropriées. Dans ce cas, l’authentification principale est l’administrateur et la deuxième est l’utilisateur nouvellement créé.
Mise à jour 20161108 - réponse originale ci-dessous
Firebase vient de publier son SDK firebase-admin, qui autorise le code côté serveur pour ce cas d’utilisation administratif commun. Lisez les instructions d'installation puis plongez dans la documentation sur la création d'utilisateurs .
réponse originale
Ceci n'est actuellement pas possible. La création d'un utilisateur Email + Mot de passe connecte automatiquement ce nouvel utilisateur.
J'ai eu un problème similaire, alors j'ai posé la question dans la Firebase Slack Community. J'ai implémenté ceci, et cela fonctionne comme un charme.
J'ai eu la solution très astucieuse d'André travaillant en Objective-C avec le SDK Firebase iOS:
NSString *plistPath = [[NSBundle mainBundle] pathForResource:@"GoogleService-Info" ofType:@"plist"];
FIROptions *secondaryAppOptions = [[FIROptions alloc] initWithContentsOfFile:plistPath];
[FIRApp configureWithName:@"Secondary" options:secondaryAppOptions];
FIRApp *secondaryApp = [FIRApp appNamed:@"Secondary"];
FIRAuth *secondaryAppAuth = [FIRAuth authWithApp:secondaryApp];
[secondaryAppAuth createUserWithEmail:user.email
password:user.password
completion:^(FIRUser * _Nullable user, NSError * _Nullable error) {
[secondaryAppAuth signOut:nil];
}];
Je viens de créer une fonction Firebase qui se déclenche lorsqu'un document Firestore est créé (avec des règles en écriture seule pour l'administrateur). Ensuite, utilisez admin.auth (). CreateUser () pour créer le nouvel utilisateur correctement.
export const createUser = functions.firestore
.document('newUsers/{userId}')
.onCreate(async (snap, context) => {
const userId = context.params.userId;
const newUser = await admin.auth().createUser({
disabled: false,
displayName: snap.get('displayName'),
email: snap.get('email'),
password: snap.get('password'),
phoneNumber: snap.get('phoneNumber')
});
// You can also store the new user in another collection with extra fields
await admin.firestore().collection('users').doc(newUser.uid).set({
uid: newUser.uid,
email: newUser.email,
name: newUser.displayName,
phoneNumber: newUser.phoneNumber,
otherfield: snap.get('otherfield'),
anotherfield: snap.get('anotherfield')
});
// Delete the temp document
return admin.firestore().collection('newUsers').doc(userId).delete();
});
Mise à jour pour Swift 4
J'ai essayé différentes options pour créer plusieurs utilisateurs à partir d'un seul compte, mais c'est de loin la solution la meilleure et la plus simple.
Réponse originale de Nico
Commencez par configurer Firebase dans votre fichier AppDelegate.Swift.
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplicationLaunchOptionsKey: Any]?) -> Bool {
// Override point for customization after application launch.
FirebaseApp.configure()
FirebaseApp.configure(name: "CreatingUsersApp", options: FirebaseApp.app()!.options)
return true
}
Ajoutez le code suivant à l’action où vous créez les comptes.
if let secondaryApp = FirebaseApp.app(name: "CreatingUsersApp") {
let secondaryAppAuth = Auth.auth(app: secondaryApp)
// Create user in secondary app.
secondaryAppAuth.createUser(withEmail: email, password: password) { (user, error) in
if error != nil {
print(error!)
} else {
//Print created users email.
print(user!.email!)
//Print current logged in users email.
print(Auth.auth().currentUser?.email ?? "default")
try! secondaryAppAuth.signOut()
}
}
}
}
La version Swift:
FIRApp.configure()
// Creating a second app to create user without logging in
FIRApp.configure(withName: "CreatingUsersApp", options: FIRApp.defaultApp()!.options)
if let secondaryApp = FIRApp(named: "CreatingUsersApp") {
let secondaryAppAuth = FIRAuth(app: secondaryApp)
secondaryAppAuth?.createUser(...)
}
Si vous utilisez Polymer et Firebase (polymerfire), voyez cette réponse: https://stackoverflow.com/a/46698801/1821603
En gros, vous créez un <firebase-app> secondaire pour gérer le nouvel enregistrement d'utilisateur sans affecter l'utilisateur actuel.
Solution Android (Kotlin):
- Vous avez besoin de FirebaseOptions BUILDER (!) Pour définir l’application api key, db url, etc.
- Créez une variable d'authentification secondaire en appelant FirebaseApp.initializeApp ()
Obtenez une instance de FirebaseAuth en passant votre nouvelle autorisation secondaire et faites ce que vous voulez (par exemple, createUser)
// 1. you can find these in your project settings under general tab val firebaseOptionsBuilder = FirebaseOptions.Builder() firebaseOptionsBuilder.setApiKey("YOUR_API_KEY") firebaseOptionsBuilder.setDatabaseUrl("YOUR_DATABASE_URL") firebaseOptionsBuilder.setProjectId("YOUR_PROJECT_ID") firebaseOptionsBuilder.setApplicationId("YOUR_APPLICATION_ID") //not sure if this one is needed val firebaseOptions = firebaseOptionsBuilder.build() // indeterminate progress dialog *ANKO* val progressDialog = indeterminateProgressDialog(resources.getString(R.string.progressDialog_message_registering)) progressDialog.show() // 2. second auth created by passing the context, firebase options and a string for secondary db name val newAuth = FirebaseApp.initializeApp(this@ListActivity, firebaseOptions, Constants.secondary_db_auth) // 3. calling the create method on our newly created auth, passed in getInstance FirebaseAuth.getInstance(newAuth).createUserWithEmailAndPassword(email!!, password!!) .addOnCompleteListener { it -> if (it.isSuccessful) { // 'it' is a Task<AuthResult>, so we can get our newly created user from result val newUser = it.result.user // store wanted values on your user model, e.g. email, name, phonenumber, etc. val user = User() user.email = email user.name = name user.created = Date().time user.active = true user.phone = phone // set user model on /db_root/users/uid_of_created_user/, or wherever you want depending on your structure FirebaseDatabase.getInstance().reference.child(Constants.db_users).child(newUser.uid).setValue(user) // send newly created user email verification link newUser.sendEmailVerification() progressDialog.dismiss() // sign him out FirebaseAuth.getInstance(newAuth).signOut() // DELETE SECONDARY AUTH! thanks, Jimmy :D newAuth.delete() } else { progressDialog.dismiss() try { throw it.exception!! // catch exception for already existing user (e-mail) } catch (e: FirebaseAuthUserCollisionException) { alert(resources.getString(R.string.exception_FirebaseAuthUserCollision), resources.getString(R.string.alertDialog_title_error)) { okButton { isCancelable = false } }.show() } } }
Swift 5: une solution simple
Commencez par stocker l'utilisateur actuel dans une variable appelée originalUser
let originalUser = Auth.auth().currentUser
Ensuite, dans le gestionnaire d'achèvement de la création d'un nouvel utilisateur, utilisez la méthode updateCurrentUser pour restaurer l'utilisateur d'origine.
Auth.auth().updateCurrentUser(originalUser, completion: nil)
Vous pouvez utiliser la fonction firebase pour ajouter des utilisateurs.
const functions = require('firebase-functions');
const admin = require('firebase-admin');
admin.initializeApp();
const cors = require('cors')({
Origin: true,
});
exports.AddUser = functions.https.onRequest(( req, res ) => {
// Grab the text parameter.
cors( req, res, () => {
let email = req.body.email;
let passwd = req.body.passwd;
let role = req.body.role;
const token = req.get('Authorization').split('Bearer ')[1];
admin.auth().verifyIdToken(token)
.then(
(decoded) => {
// return res.status(200).send( decoded )
return creatUser(decoded);
})
.catch((err) => {
return res.status(401).send(err)
});
function creatUser(user){
admin.auth().createUser({
email: email,
emailVerified: false,
password: passwd,
disabled: false
})
.then((result) => {
console.log('result',result);
return res.status(200).send(result);
}).catch((error) => {
console.log(error.message);
return res.status(400).send(error.message);
})
}
});
});
Solution Android (Java):
Rien de plus, changez-le simplement en Java et merci à fkvestak pour la solution Android en tant que référence de tâche de stage. https://stackoverflow.com/a/52162643/11726855
FirebaseAuth fba = FirebaseAuth.getInstance();
DatabaseReference dbr = FirebaseDatabase.getInstance().getReference("users");
ProgressDialog pd = new ProgressDialog(this);
public void [ON_CLICK](View view) {
pd.setMessage("Adding User....");
pd.show();
//These can be found in your project settings under General tab
//Server key under Cloud Messaging tab is not the API key, I've been confused by other posts
FirebaseOptions.Builder fbo = new FirebaseOptions.Builder();
fbo.setApiKey("YOUR_WEB_API_KEY");
fbo.setDatabaseUrl("https://[YOUR_PROJECT_ID].firebaseio.com/");
fbo.setProjectId("YOUR_PROJECT_ID");
fbo.setApplicationId("YOUR_APP_ID"); //Tested, App Id is required.
FirebaseOptions firebaseOptions = fbo.build();
final FirebaseApp secondaryAuth = FirebaseApp.initializeApp([Java_CLASS_NAME].this, firebaseOptions, "secondary_db_auth");
FirebaseAuth.getInstance(secondaryAuth).createUserWithEmailAndPassword(addUserEmail, addUserPassword)
.addOnCompleteListener(this,
new OnCompleteListener<AuthResult>() {
@Override
public void onComplete(@NonNull Task<AuthResult> task) {
pd.dismiss();
if (task.isSuccessful()) {
//Can inline as "dbr.child(addUserName).setValue(users);", but I don't like the green box
String key = addUserName;
//Reusable constructor
UserFD users = new UserFD(addUserName, addUserPassword, addUserAuthorisation);
dbr.child(key).setValue(users);
throwSecondaryAuth(secondaryAuth);
Toast.makeText(getApplicationContext(),
"Add User Successful", Toast.LENGTH_SHORT).show();
} else {
//Sorry that still weak in playing with exception, so I use toast
throwSecondaryAuth(secondaryAuth);
Toast.makeText(getApplicationContext(),
"Add User Failed", Toast.LENGTH_SHORT).show();
}
}
});
}
Voici l'identifiant du projet, la clé API et l'identifiant de l'application.
Et c'est l'URL de la base de données
Que les choses soient réutilisables ......
public void throwSecondaryAuth(FirebaseApp secondAuth) {
FirebaseAuth.getInstance(secondAuth).signOut();
secondAuth.delete();
}
Voici une adaptation Swift 3 de Réponse de Cabrera :
let bundle = Bundle.main
let path = bundle.path(forResource: "GoogleService-Info", ofType: "plist")!
let options = FIROptions.init(contentsOfFile: path)
FIRApp.configure(withName: "Secondary", options: options!)
let secondary_app = FIRApp.init(named: "Secondary")
let second_auth = FIRAuth(app : secondary_app!)
second_auth?.createUser(withEmail: self.username.text!, password: self.password.text!)
{
(user,error) in
print(user!.email!)
print(FIRAuth.auth()?.currentUser?.email ?? "default")
}