Obtenir les utilisateurs par propriété de nom à l'aide de Firebase

J'essaie de créer une application où 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 j'ai est que je ne sais pas comment cibler des données d'utilisateurs spécifiques lorsque ma structure ressemble à ceci:

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

J'ai regardé autour de moi et je ne trouve vraiment rien sur la façon d'accéder aux données individuelles et encore moins quand on leur donne un hachage aléatoire comme identifiant.

Comment dois-je procéder pour récupérer les informations des utilisateurs individuels en fonction de leur nom? S'il y a une meilleure façon de faire cela, dites-le moi!

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

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

Lorsque vous écrivez des données sur Firebase, vous disposez de quelques options différentes qui reflètent différents cas d'utilisation. À un niveau élevé, Firebase est un magasin de données NoSQL à structure arborescente et fournit quelques primitives simples pour gérer des listes de données:

1. Écrivez dans Firebase avec une clé unique et connue:

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

2. Ajouter aux listes avec une clé générée automatiquement qui triera automatiquement par heure écrite:

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

3. Écoutez les modifications des données par leur chemin unique et connu:

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

4. Filtrer ou ordonner les données dans 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 avec le nom «Alex»:

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

Ingénieur chez Firebase ici. Lorsque vous écrivez des données dans Firebase, vous disposez de quelques options différentes qui reflètent différents cas d'utilisation d'application. Puisque Firebase est un magasin de données NoSQL, vous devrez soit stocker vos objets de données avec des clés uniques afin de pouvoir accéder directement à cet élément, soit charger toutes les données à un emplacement particulier et parcourir chaque élément pour trouver le nœud que vous recherchez . Voir Écriture de données et gestion de listes pour plus d'informations.

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

Plutôt que d'utiliser pushici, je recommanderais d'utiliser setet de stocker les données de chaque utilisateur à l'aide d'une clé unique, telle que l'adresse e-mail 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.

Vous pouvez récupérer les détails par le 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()); 
                    }

Je pense que la meilleure approche est de définir les identifiants des utilisateurs en fonction de l'objet auth fourni par Firebase. Lorsque je crée mes utilisateurs, je fais:

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

Cet identifiant provient 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 sera défini à uid. De cette façon, vous aurez toujours le auth.uid et pourrez facilement accéder à l'utilisateur souhaité pour le mettre à jour, comme:

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

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

Merci, Bennlich (source):

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

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

Edit: Pas sûr à 100% 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();
});

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

Le moyen le plus simple est d'arrêter d'utiliser le .push(){}

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

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(), donc si vous souhaitez récupérer les données, procédez comme suit:

Utilisation de Firebase dans l'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), userspuis vous bouclez à l'intérieur de tous les identifiants aléatoires et récupérez les noms.

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

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

Utilisation de Firebase dans l'application Android:

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

Utiliser 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"qu'il récupérera les données liées à Alex.

Meilleur moyen:

La meilleure chose à faire est d'utiliser l'authentification Firebase, générant ainsi un identifiant unique pour chaque utilisateur et en l'utilisant à la place d'un identifiant aléatoire push(), de cette façon, vous n'avez pas à parcourir tous les utilisateurs puisque vous avez l'identifiant et pouvez facilement y accéder.

Tout d'abord, l'utilisateur doit être connecté, puis vous pouvez récupérer l'identifiant unique et attacher 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;
   });
 

Le moyen le plus simple et le meilleur pour ajouter un identifiant unique à votre 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'interface utilisateur sera un identifiant unique pour un e-mail / utilisateur authentifié spécifique