Firebase Android: crea un nome utente univoco

Question

L'analisi si spegne alla fine dell'anno, quindi ho deciso di iniziare a utilizzare Firebase. Devo implementare un processo di registrazione con 3 campi: email, nome utente, password (Email & nome utente deve essere univoco per la mia app).

Dal momento che Firebase non fornisce un modo semplice per gestire il nome utente come Parse, ho deciso di utilizzare solo la registrazione email/password e di salvare alcuni dati aggiuntivi come il nome utente. Qui è la mia struttura dati degli utenti:

app : { 
    users: { 
     "some-user-uid": { 
      email: "test@test.com" 
      username: "myname" 
     } 
    } 
} 

Ma, quello che voglio fare è quello di rendere il nome utente unico e per verificare prima di creare un account. Queste sono le mie regole:

{ 
    "rules": { 
     ".read": true, 
     ".write": true, 
     "users": { 
      "$uid": { 
       ".write": "auth !== null && auth.uid === $uid", 
       ".read": "auth !== null && auth.provider === 'password'", 
       "username": {".validate": "!root.child('users').child(newData.child('username').val()).exists()"} 
      } 
     } 
    } 
} 

La ringrazio molto per il vostro aiuto

Answer 1

Parte della risposta è quello di memorizzare un indice di nomi utente, che si controlla contro nelle regole di sicurezza:

app : { 
    users: { 
     "some-user-uid": { 
      email: "test@test.com" 
      username: "myname" 
     } 
    }, 
    usernames: { 
     "myname": "some-user-uid" 
    } 
} 

Quindi il nodo usernames associa un nome utente a un uid. In sostanza si legge come "username 'myname' è di proprietà di 'some-user-uid'".

Con questa struttura dati, le regole di sicurezza può controllare se esiste già una voce per un determinato nome utente:

"users": { 
    "$uid": { 
    ".write": "auth !== null && auth.uid === $uid", 
    ".read": "auth !== null && auth.provider === 'password'", 
    "username": { 
     ".validate": " 
     !root.child('usernames').child(newData.val()).exists() || 
     root.child('usernames').child(newData.val()).val() == $uid" 
    } 
    } 
} 

Ciò conferma che il nome utente non è sostenuto da nessuno eppure O si sostiene dal utente attuale.

Answer 2

Non so ancora molto sulla sicurezza di Firebase, ma potrei aver risolto il problema utilizzando Java. L'ho pubblicato qui sotto.

mia struttura dati è

myapp 
{ 
    users: { 
      <unique generated-id> 
      { username: "example.username" } 
} 
} 


public boolean isUsernameExists(final String enteredUsername) { 
     final Boolean[] isExist = {false}; 
     FBref.child("users").addValueEventListener(new ValueEventListener() { 
      @Override 
      public void onDataChange(DataSnapshot dataSnapshot) { 
       for (DataSnapshot userSnapshot : dataSnapshot.getChildren()) { 
        String existingUsername = (String) userSnapshot.child("userName").getValue(); 
        if (existingUsername.equals(enteredUsername)) { 
         isExist[0] = true; 
        } 
       } 
      } 
      @Override 
      public void onCancelled(FirebaseError firebaseError) { 
       //some error thrown here 
      } 
     }); 
     return isExist[0]; 
    } 

Answer 3

Salva nomi utente come suggerito da Frank, ma quando si salva nomi utente, utilizzare la funzione runTransaction in Firebase per assicurarsi che il nome utente non è stata presa. Questa funzione è garantita da Firebase per essere un'operazione atomica in modo che tu possa essere certo di nessuna collisione

firebaseRef.child("usernames").child(username).runTransaction(new Transaction.Handler() { 
    @Override 
    public Transaction.Result doTransaction(MutableData mutableData) { 
     if (mutableData.getValue() == null) { 
      mutableData.setValue(authData.getUid()); 
      return Transaction.success(mutableData); 
     } 

     return Transaction.abort(); 
    } 

    @Override 
    public void onComplete(FirebaseError firebaseError, boolean commited, DataSnapshot dataSnapshot) { 
     if (commited) { 
      // username saved 
     } else { 
      // username exists 
     } 
    } 
});