web-dev-qa-db-fra.com

Obtenir les utilisateurs par leur propriété en utilisant Firebase

J'essaie de créer une application dans laquelle je peux obtenir/définir des données dans des comptes d'utilisateurs spécifiques et j'ai été tenté par Firebase.

Le problème que je rencontre est que je ne sais pas comment cibler des données d'utilisateurs spécifiques lorsque ma structure ressemble à ceci: 

My data structure described by the text below.

online-b-cards
  - users
    - InnROTBVv6FznK81k3m
       - email: "hello@hello"
       - main:  "Hello world this is a text"
       - name:  "Alex"
       - phone: 12912912

J'ai jeté un coup d'œil autour de moi et je ne trouve pas vraiment comment accéder à des données individuelles, encore moins quand on leur donne un hash aléatoire.

Comment pourrais-je obtenir des informations sur les utilisateurs individuels en fonction de leur nom? S'il y a une meilleure façon de le faire, dites-le-moi!

firebasefirebase-realtime-database
122
Richard Bamford

Auparavant, Firebase vous demandait de générer vos propres index ou télécharger toutes les données à un emplacement pour rechercher et extraire les éléments correspondant à certains attributs enfants (par exemple, tous les utilisateurs avec name === "Alex").

En octobre 2014, Firebase a déployé une nouvelle fonctionnalité de requête via la méthode orderByChild(), qui vous permet d'effectuer ce type de requête rapidement et efficacement. Voir la réponse mise à jour ci-dessous.

Lors de l'écriture de données sur Firebase, vous disposez de plusieurs options qui reflètent différents cas d'utilisation. À un niveau élevé, Firebase est un magasin de données NoSQL structuré en arbre et fournit quelques primitives simples pour la gestion de listes de données:

  1. Write to Firebase avec une clé unique et connue:

    ref.child('users').child('123').set({ "first_name": "rob", "age": 28 })

  2. Ajouter à des listes avec une clé générée automatiquement qui seront triées automatiquement par le temps écrit:

    ref.child('users').Push({ "first_name": "rob", "age": 28 })

  3. Listen pour les modifications de données par son chemin unique et connu:

    ref.child('users').child('123').on('value', function(snapshot) { ... })

  4. Filtre ou ordre données d'une liste par clé ou valeur d'attribut:

    // Get the last 10 users, ordered by key
ref.child('users').orderByKey().limitToLast(10).on('child_added', ...)

// Get all users whose age is >= 25
ref.child('users').orderByChild('age').startAt(25).on('child_added', ...)

Avec l'ajout de orderByChild(), vous n'avez plus besoin de créer votre propre index pour les requêtes sur les attributs enfants! Par exemple, pour récupérer tous les utilisateurs portant le nom "Alex":

ref.child('users').orderByChild('name').equalTo('Alex').on('child_added',  ...)

Ingénieur à Firebase ici. Lors de l'écriture de données dans Firebase, vous disposez de plusieurs options qui reflètent différents cas d'utilisation d'applications. Firebase étant un magasin de données NoSQL, vous devez stocker vos objets de données avec des clés uniques afin de pouvoir accéder directement à cet élément, ou charger toutes les données à un emplacement particulier et parcourir chaque élément pour rechercher le nœud que vous recherchez. pour. Voir Écriture de données et Gestion de listes pour plus d'informations.

Lorsque vous écrivez des données dans Firebase, vous pouvez soit utiliser des données set en utilisant un chemin unique défini (par exemple, a/b/c), ou des données Push, ce qui générera un identifiant unique (par exemple, a/b/<unique-id>) et vous permettra de trier et d'interroger les éléments cette liste par le temps. L'identifiant unique que vous voyez ci-dessus est généré en appelant Push pour ajouter un élément à la liste en online-b-cards/users.

Plutôt que d'utiliser Push ici, je recommanderais d'utiliser set et de stocker les données de chaque utilisateur à l'aide d'une clé unique, telle que l'adresse électronique de l'utilisateur. Ensuite, vous pouvez accéder directement aux données de l'utilisateur en accédant à online-b-cards/users/<email> via le SDK Firebase JS. Par exemple:

function escapeEmailAddress(email) {
  if (!email) return false

  // Replace '.' (not allowed in a Firebase key) with ',' (not allowed in an email address)
  email = email.toLowerCase();
  email = email.replace(/\./g, ',');
  return email;
}

var usersRef = new Firebase('https://online-b-cards.firebaseio.com/users');
var myUser = usersRef.child(escapeEmailAddress('[email protected]')) 
myUser.set({ email: '[email protected]', name: 'Alex', phone: 12912912 });

Notez que puisque Firebase n'autorise pas certains caractères dans les références (voir Création de références ), nous supprimons le . et le remplaçons par un , dans le code ci-dessus.

150
Rob DiMarco

Vous pouvez récupérer les détails à l'aide du code suivant.

FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference myRef = database.getReference("users");
myRef.orderByChild("name").equalTo("Alex").addListenerForSingleValueEvent(new ValueEventListener() {           
                @Override
                public void onDataChange(DataSnapshot dataSnapshot) {

                    for (DataSnapshot childDataSnapshot : dataSnapshot.getChildren()) {
                        Log.d(TAG, "PARENT: "+ childDataSnapshot.getKey());
                        Log.d(TAG,""+ childDataSnapshot.child("name").getValue()); 
                    }
5
Nabajyoti Das

Je pense que la meilleure approche consiste à définir les identifiants des utilisateurs en fonction de l’objet authentification fourni par Firebase. Quand je crée mes utilisateurs, je fais:

FirebaseRef.child('users').child(id).set(userData);

Cet identifiant vient de:

var ref = new Firebase(FIREBASE);
var auth = $firebaseAuth(ref);
auth.$authWithOAuthPopup("facebook", {scope: permissions}).then(function(authData) {
    var userData = {}; //something that also comes from authData
    Auth.register(authData.uid, userData);
}, function(error) {
    alert(error);
});

Les services d'authentification Firebase garantiront toujours qu'un identifiant unique parmi tous leurs fournisseurs soit défini sur uid. De cette façon, vous aurez toujours le fichier auth.uid et pourrez facilement accéder à l’utilisateur souhaité pour le mettre à jour, par exemple:

FirebaseRef.child('users').child(id).child('name').set('Jon Snow');
4
diegopso

Voici comment accéder aux clés uniques générées automatiquement dans Firebase: structure de données : - OnlineBcards - UniqueKey

database.ref().on("value", function(snapshot) {
      // storing the snapshot.val() in a variable for convenience
      var sv = snapshot.val();
      console.log("sv " + sv); //returns [obj obj]

      // Getting an array of each key in the snapshot object
      var svArr = Object.keys(sv);
      console.log("svArr " + svArr); // [key1, key2, ..., keyn]
      // Console.log name of first key
      console.log(svArr[0].name);
}, function(errorObject) {
  console.log("Errors handled: " + errorObject.code);
});
2
Juan Reyes

C’était la paraphrase d’un message qui m’a aidé à accéder à l’identifiant unique généré automatiquement. Accédez aux ID uniques Firebase dans ng-repeat à l'aide de la synchronisation implicite angularFire

Merci, bennlich (source):

Firebase se comporte comme un objet javascript normal. Peut-être que l'exemple ci-dessous peut vous mettre sur la bonne voie.

<div ng-repeat="(name, user) in users">
    <a href="" ng-href="#/{{name}}">{{user.main}}</a>
</div>

Edit: Pas 100% sûr du résultat souhaité, mais voici un peu plus qui pourrait déclencher un moment "aha". Cliquez sur la clé à laquelle vous essayez d'accéder directement dans votre tableau de bord Firebase. De là, vous pouvez utiliser quelque chose comme:

var ref = new Firebase("https://online-b-cards.firebaseio.com/users/<userId>/name);
    ref.once('value', function(snapshot) {
        $scope.variable= snapshot.val();
});
2
AnthonyC

Le moyen le plus simple est de ne plus utiliser la fonction .Push(){} 

fonction qui va générer cette clé aléatoire. Mais utilisez plutôt la fonction .update(){} où vous pouvez spécifier le nom de l’enfant au lieu d’avoir la clé aléatoire. 

1
Miah Thompson

Récupération des données:

Dans votre base de données, vous utilisez un identifiant aléatoire généré à l'aide de Push(). Par conséquent, si vous souhaitez récupérer les données, procédez comme suit:

Utilisation de Firebase dans une application Android:

DatabaseReference ref=FirebaseDatabase.getInstance().getReference().child("users");
ref.addListenerForSingleValueEvent(new ValueEventListener() {           
            @Override
            public void onDataChange(DataSnapshot dataSnapshot) {

                for (DataSnapshot datas : dataSnapshot.getChildren()) {
                    String name=datas.child("name").getValue().toString();
                }
             }

            @Override
           public void onCancelled(DatabaseError databaseError) {
          }
     });

Utilisation de Firebase en Javascript:

  firebase.database().ref().child("users").on('value', function (snapshot) {
   snapshot.forEach(function(childSnapshot) {
    var name=childSnapshot.val().name;
  });
});

Ici, vous avez l’instantané (emplacement des données) à users, puis vous passez en boucle dans tous les identifiants aléatoires et récupérez les noms.

Récupération de données pour un utilisateur spécifique:

Maintenant, si vous voulez récupérer des informations pour un utilisateur spécifique uniquement, vous devez ajouter une requête:

Utilisation de Firebase dans une application Android:

DatabaseReference ref=FirebaseDatabase.getInstance().getReference().child("users");
Query queries=ref.orderByChild("name").equalTo("Alex");
queries.addListenerForSingleValueEvent(new ValueEventListener() {...}

Utilisation de Firebase avec Javascript

firebase.database().ref().child("users").orderByChild("name").equalTo("Alex").on('value', function (snapshot) {
   snapshot.forEach(function(childSnapshot) {
      var name=childSnapshot.val().name;
   });
});

Utiliser orderByChild("name").equalTo("Alex") revient à dire where name="Alex" pour récupérer les données relatives à Alex.

Meilleur moyen:

La meilleure chose à faire est d'utiliser l'authentification Firebase afin de générer un identifiant unique pour chaque utilisateur et de l'utiliser au lieu d'un identifiant aléatoire Push(). Ainsi, vous n'avez pas à parcourir tous les utilisateurs puisque vous avez l'identifiant et pouvez y accéder facilement.

Tout d'abord, l'utilisateur doit être connecté, puis vous pouvez récupérer l'identifiant unique et associer un écouteur pour récupérer les autres données de cet utilisateur:

Utilisation de Firebase avec Android:

DatabaseReference ref = FirebaseDatabase.getInstance().getReference("users");
String uid = FirebaseAuthentication.getInstance().getCurrentUser().getUid();

ref.child(uid).addListenerForSingleValueEvent(new ValueEventListener() {
          @Override
         public void onDataChange(DataSnapshot dataSnapshot) { 
           String name=dataSnapshot.child("name").getValue().toString(); 
   }
         @Override
       public void onCancelled(DatabaseError databaseError) {
      }
 });

Utilisation de Firebase avec Javascript:

    var user = firebase.auth().currentUser;
    var uid=user.uid;

    firebase.database().ref().child("users").child(uid).on('value', function (snapshot) {
     var name=snapshot.val().name;
   });
1
Peter Haddad

Le moyen le plus simple et le plus efficace d’ajouter un identifiant unique à la base de données en fonction de l’utilisateur authentifié est le suivant:

private FirebaseAuth auth;

String UId=auth.getCurrentUser().getUid();

FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference myRef = database.getReference("Users");

User user = new User(name,email,phone,address,dob,bloodgroup);

myRef.child(UId).setValue(user);

L'UId sera un identifiant unique pour un utilisateur/email authentifié spécifique 

0
M.Usman Younas