for loop inside the firebase listen is not updating

Question

In my application i want call data from firebase different collections. First I want to list all items and take the id. Using that id i want to retrieve price from price collection. After that i want to retrieve data from discount. for taking discount. Here i am using loops. In the below code the output is coming. First loading list after that it calling second collection price. Any one know the solution. I want to listen for calling three collection. Because if any data change i want to update.

    @override
    void initState() {
        super.initState();
        _loadItems();
    }


    Future _loadItems() async {

            int price;
            int discount;

            //calling first collection for getting id and name
            firestore.collection("item").snapshots().listen((itemData)async{

                for(int i=0;i<itemData.documents.length;i++){

                // calling second collection for getting price
                firestore.collection("price").where("id",isEqualTo: itemData.documents[i].data["id"])
                .snapshots().listen((priceData) async{
                        price=priceData.documents[0].data['price'];
                        debugPrint("price showing before loading:"+price.toString());

                                //calling third collection for getting discount
                                firestore.collection("discount")
                                .where("id",isEqualTo: itemData.documents[i].data["id"])
                                .snapshots().listen((discountData) async{
                                    for(int j=0;j<discountData.documents.length;j++){
                                        discount=discountData.documents.data['discount'];
                                    }
                                });

                });

                    setState(() {
                    debugPrint("price showing after loading:"+price.toString());
                    this.documents.add(new CartProduct(
                        name:itemData.documents[i].data["id"],
                        label:itemData.documents[i].data["label"],
                        price:price,
                        discount:discount

                    ));
                    });

                }
        });


    }

Present output

    price showing after loading:0
    price showing after loading:0
    price showing after loading:0
    price showing before loading:10.0
    price showing before loading:10.0
    price showing before loading:10.0

Expected output

    price showing before loading:10.0
    price showing before loading:10.0
    price showing before loading:10.0
    price showing after loading:10.0
    price showing after loading:10.0
    price showing after loading:10.0

Answer 1

I have got answer Use StreamSubscription and call one by one. First I run one loop and check whether it is completed or not than after only call second loop. It working fine but taking delays. when I using StreamBuilder it not completing the request. I don't know why it happening. My code is shown below.

    StreamSubscription<QuerySnapshot> streamSub1;
    StreamSubscription<QuerySnapshot> streamSub2;
    StreamSubscription<QuerySnapshot> streamSub3;

    var list = new List();


    _loadItems() {

                int price;
                int discount;

                int count =1;

                //calling first collection for getting id and name
            streamSub1= firestore.collection("item").snapshots().listen((itemData)async{


                    for(int i=0;i<itemData.documents.length;i++){
                        list.add(id:itemData.documents[0].data['id'],name:itemData.documents[0].data['id');

                        if(onFavData.documents.length==productCount){
                            debugPrint("loop completed");
                            _loadPrice();
                        }
                    }


            });


    }

    void _loadPrice(){
    streamSub1.cancel();

    int count =1;

    for(int i=0;i<list.length;i++){
        streamSub2= firestore.collection("price").where("id",isEqualTo: itemData.documents[i].data["id"])
                    .snapshots().listen((priceData) async{
                    list[i].price= priceData['price'];
                    if(count==list.length){
                debugPrint("loop completed");
                _loadDiscount();
                }

        });

    }

    }

    _loadDiscount();{
    streamSub2.cancel();

    int count =1;

    for(int i=0;i<list.length;i++){
        streamSub3= firestore.collection("price").where("id",isEqualTo: itemData.documents[i].data["id"])
                    .snapshots().listen((priceData) async{
                    list[i].discount= priceData['price'];
                    if(count==list.length){
                debugPrint("loop completed");

                }

        });

    }

    }

Answer 2

This is my code. I will explain it step by step so you can convert it to your's.

buildUserActions returns a StreamBuilder that StreamBuilder takes all documents which is in actions collection in cloud firestore. When ConnectionState is active, or done if I have data I assign it to variable named _lastActionDocuments.

  QuerySnapshot _lastActionDocuments;
  Stream<String> streamOfFillActionFields;

  Widget buildUserActions() {
    return StreamBuilder(
      initialData: _lastActionDocuments,
      stream: Firestore.instance.collection('actions').snapshots(),
      builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) {
        switch (snapshot.connectionState) {
          case ConnectionState.none:
          case ConnectionState.waiting:
            return Center(
              child: CircularProgressIndicator(),
            );
          case ConnectionState.active:
          case ConnectionState.done:
            if (snapshot.hasError)
              return Center(child: Text('Error: ${snapshot.error}'));
            if (!snapshot.hasData) return Text('No data finded!');
            _lastActionDocuments = snapshot.data;
            streamOfFillActionFields = fillActionFields();
            return reallyBuildActions();
        }
      },
    );
  }

then I have a Stream function

  Stream<String> fillActionFields() async* {
    try {
      List<ActionModel> newActionList = [];
      for (DocumentSnapshot actionSnapshot in _lastActionDocuments.documents) {
        var currentAction = ActionModel.fromSnapshot(actionSnapshot);
        // I awaiting to get and fill all data.
        await currentAction.fillAllFields();
        newActionList.add(currentAction);
      }
      actionList = newActionList;
      // what I yield is not important this case 
      yield 'data';
    } catch (e) {
      print(e);
      yield 'nodata';
    }
  }

currentAction.fillAllFields basicly that function ask to firebase to get the related data to fill all fields in my Action Object.

  Future<void> fillAllFields() async {
    DocumentSnapshot ownerSnapshot = await ownerRef.get();
    owner = UserModel.fromSnapshot(ownerSnapshot);
    DocumentSnapshot routeSnapshot = await routeRef.get();
    route = RouteModel.fromSnapshot(routeSnapshot);
  }

then I have another widget which is returning a StreamBuilder. this widget build the real UI widget(buildAllActions) after all data arrived from reference calls.

  Widget reallyBuildActions() {
    return StreamBuilder(
      stream: streamOfFillActionFields,
      builder: (BuildContext context, AsyncSnapshot<String> snapshot) {
        switch (snapshot.connectionState) {
          case ConnectionState.none:
          case ConnectionState.waiting:
            return Center(
              child: CircularProgressIndicator(),
            );
          case ConnectionState.active:
          case ConnectionState.done:
            if (snapshot.data == 'data') {
              return buildAllActions();
            } else {
              return Center(
                child: Column(
                  children: <Widget>[
                    CircularProgressIndicator(),
                    Text('Data Loading...')
                  ],
                ),
              );
            }
        }
      },
    );
  }

Answer 3

I thing you can use nested StreamBuilder's

Widget getTripleCollectionFromFirebase() {
  return StreamBuilder<QuerySnapshot>(
    stream: Firestore.instance.collection("item").snapshots(),
    builder: (BuildContext context, AsyncSnapshot<QuerySnapshot> snapshot) {
      if (snapshot.hasError) return Text("Error: ${snapshot.error}");
      switch (snapshot.connectionState) {
        case ConnectionState.none:
          return Text("No data, yet.");
        case ConnectionState.waiting:
          return Text('Loading...');
        case ConnectionState.active:
        case ConnectionState.done:
          if (snapshot.data == null) {
            return Text("No record");
          } else {
            // Do your staff after first query then call the other collection
            return StreamBuilder<QuerySnapshot>(
              stream: Firestore.instance
                  .collection("price")
                  .where("id", isEqualTo: "fill_it_with_your_code")
                  .snapshots(),
              builder: (BuildContext context,
                  AsyncSnapshot<QuerySnapshot> snapshot) {
                if (snapshot.hasError) return Text("Error: ${snapshot.error}");
                switch (snapshot.connectionState) {
                  case ConnectionState.none:
                    return Text("No data, yet.");
                  case ConnectionState.waiting:
                    return Text('Loading...');
                  case ConnectionState.active:
                  case ConnectionState.done:
                    if (snapshot.data == null) {
                      return Text("No record");
                    } else {
                      // do your staff after second Query
                      return StreamBuilder<QuerySnapshot>(
                        stream: Firestore.instance
                            .collection("discount")
                            .where("id", isEqualTo: "something")
                            .snapshots(),
                        builder: (BuildContext context,
                            AsyncSnapshot<QuerySnapshot> snapshot) {
                          if (snapshot.hasError)
                            return Text("Error: ${snapshot.error}");
                          switch (snapshot.connectionState) {
                            case ConnectionState.none:
                              return Text("No data, yet.");
                            case ConnectionState.waiting:
                              return Text('Loading...');
                            case ConnectionState.active:
                            case ConnectionState.done:
                              if (snapshot.data == null) {
                                return Text("No record");
                              } else {
                                // do your staff after third Query
                                // return the widget which you want to build when all data comes.
                              }
                          }
                        },
                      );
                    }
                }
              },
            );
          }
      }
    },
  );
}