Firebase startet den aktuellen Benutzer

Update 20161108 - ursprüngliche Antwort unten

Firebase hat gerade sein firebase-admin SDK veröffentlicht, das serverseitigen Code für diesen und andere gängige administrative Anwendungsfälle ermöglicht. Lesen Sie die Installationsanweisungen und tauchen Sie dann in die Dokumentation zum Erstellen von Benutzern ein.

ursprüngliche Antwort

Dies ist derzeit nicht möglich. Das Erstellen eines E-Mail + Passwort-Benutzers meldet diesen neuen Benutzer automatisch an.

Ich hatte ein ähnliches Problem und stellte diese Frage in der Firebase Slack Community. Ich habe das umgesetzt und es funktioniert wie ein Zauber.

Ich bekam André's sehr clevere Problemumgehung Arbeit in Objective-C mit dem Firebase iOS SDK:

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

Ich habe gerade eine Firebase-Funktion erstellt, die ausgelöst wird, wenn ein Firestore-Dokument erstellt wird (mit Regeln, die nur für den Admin-Benutzer schreibgeschützt sind). Verwenden Sie dann admin.auth (). CreateUser (), um den neuen Benutzer ordnungsgemäß zu erstellen.

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

Update für Swift 4

Ich habe verschiedene Optionen ausprobiert, um mehrere Benutzer aus einem einzigen Konto zu erstellen. Dies ist jedoch bei weitem die beste und einfachste Lösung.

Ursprüngliche Antwort von Nico

Konfigurieren Sie zuerst die Firebase in Ihrer AppDelegate.Swift-Datei

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
}

Fügen Sie der Aktion, in der Sie die Konten erstellen, den folgenden Code hinzu.

            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()

                    }
                }
            }
        }

Die Swift-Version:

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(...)
}

Wenn Sie Polymer und Firebase (Polymerfire) verwenden, sehen Sie diese Antwort: https://stackoverflow.com/a/46698801/1821603

Im Wesentlichen erstellen Sie einen sekundären <firebase-app>, um die Registrierung des neuen Benutzers ohne Auswirkungen auf den aktuellen Benutzer durchzuführen.

Android-Lösung (Kotlin):

1. Sie benötigen FirebaseOptions BUILDER (!) Zum Setzen von API-Schlüssel, DB-URL usw. und vergessen Sie nicht, build () am Ende aufzurufen
2. Erstellen Sie eine sekundäre Auth-Variable, indem Sie FirebaseApp.initializeApp () aufrufen.

3. Rufen Sie die Instanz von FirebaseAuth ab, indem Sie Ihre neu erstellte sekundäre Authentifizierung übergeben, und tun Sie, was Sie möchten (z. B. 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([email protected], 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: Einfache Lösung

Speichern Sie zuerst den aktuellen Benutzer in einer Variablen namens originalUser

let originalUser = Auth.auth().currentUser

Verwenden Sie dann im Beendigungshandler zum Erstellen eines neuen Benutzers die updateCurrentUser-Methode, um den ursprünglichen Benutzer wiederherzustellen

Auth.auth().updateCurrentUser(originalUser, completion: nil)

Sie können die Firebase-Funktion zum Hinzufügen von Benutzern verwenden.

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

   }); 
 });

Android-Lösung (Java):

Nicht viel, ändere es einfach in Java und danke fkvestak für die Android Lösung als Referenz für meine Praktikumsaufgabe. 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();
                        }
                    }
                });
}

Hier ist die Projekt-ID, der API-Schlüssel und die App-ID.

nd das ist die Datenbank-URL

Lass die Dinge wiederverwendbar sein ......

public void throwSecondaryAuth(FirebaseApp secondAuth) {
    FirebaseAuth.getInstance(secondAuth).signOut();
    secondAuth.delete();
}

Hier ist eine Swift-3-Anpassung von Cabreras Antwort :

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