如何从firebase firestore子集合中获取数据？

实际上，我想从firebase子集合中获取数据

我想将子集合的数据提取到模型中

实际上，问题是它检索超级集合的数据，但在子集合中它并没有显示任何数据

这是我的第一个模型

class Order{
  Stream<List<OrderedFoodItem>> orderedFoodItemList;      <--- Here OrderedFoodItem is Second Model
  String name;

  Order({this.orderedFoodItemList, this.name});
}

第一个模型是外部模型，第二个模型是内部模型

这是我的密码

Stream<List<Order>> get getPendingOrdersList  {
    String collectionPath = uid + "pendingorders";
    final CollectionReference collectionReference = FirebaseFirestore.instance.collection(collectionPath);
    return collectionReference.snapshots().map(_orderList);
  }

  List<Order> _orderList(QuerySnapshot querySnapshot)  {
    return querySnapshot.docs.map((document){
      return Order(
        name: document.get('name'),
        orderedFoodItemList: FirebaseFirestore.instance
            .collection(uid + "pendingorders")
            .doc(document.id).collection(document.id).snapshots().map(_orderedFoodItemList),
      );
    }).toList();
  }

  List<OrderedFoodItem> _orderedFoodItemList(QuerySnapshot querySnapshot) {
    return querySnapshot.docs.map((document) {
      return OrderedFoodItem(
        foodItemName: document.get('fooditem_name'),
        foodItemPrice: document.get('fooditem_price'),
        foodItemQuantity: document.get('fooditem_quantity'),
      );
    }).toList();
  }

流获取getPendingOrdersList{
字符串collectionPath=uid+“pendingorders”；
final CollectionReference CollectionReference=FirebaseFirestore.instance.collection（collectionPath）；
返回collectionReference.snapshots（）.map（_orderList）；
}
列表_订单列表（QuerySnapshot QuerySnapshot）{
返回querySnapshot.docs.map（（文档）{
退货单(
名称：document.get（'name'），
orderedFoodItemList:FirebaseFirestore.instance
.集合（uid+“待处理订单”）
.doc（document.id）.collection（document.id）.snapshots（）.map（_orderedFoodItemList），
);
}).toList（）；
}
列表\u orderedFoodItemList（QuerySnapshot QuerySnapshot）{
返回querySnapshot.docs.map（（文档）{
返回OrderedFoodItem(
foodItemName:document.get（'fooditem_name'），
foodItemPrice:document.get（'fooditem\u price'），
foodItemQuantity:document.get（'fooditem\u quantity'），
);
}).toList（）；
}

这是我获取数据的代码

StreamBuilder<List<Order>>(
        stream: DatabaseService(uid: FirebaseAuth.instance.currentUser.uid).getPendingOrdersList,
        builder: (context, snapshot){
          if(snapshot.data != null){
            return ListView.builder(
              itemCount: snapshot.data.length,
              itemBuilder: (context, outerIndex){
                return Column(
                  children: [
                    Text(
                      snapshot.data[outerIndex].name,
                    ),
                    StreamBuilder<List<OrderedFoodItem>>(
                      stream: snapshot.data[outerIndex].orderedFoodItemList,
                      builder: (context,innerSnapshot){
                        if(innerSnapshot.data != null){
                          return ListView.builder(
                            itemCount: innerSnapshot.data.length,
                            itemBuilder: (context, innerIndex) {
                              return Column(
                                children: [
                                  Text(
                                    innerSnapshot.data[innerIndex].foodItemName
                                  ),
                                  Text(
                                      innerSnapshot.data[innerIndex].foodItemPrice
                                  ),
                                  Text(
                                      innerSnapshot.data[innerIndex].foodItemQuantity
                                  ),
                                ],
                              );
                            },
                          );
                        } else {
                          return CircularProgressIndicator();
                        }
                      },
                    ),
                  ],
                );
              },
            );
          }else{
            return Text('no data');
          }

        },
      ),

StreamBuilder(
流：DatabaseService（uid:FirebaseAuth.instance.currentUser.uid）.getPendingOrdersList，
生成器：（上下文，快照）{
如果（snapshot.data！=null）{
返回ListView.builder(
itemCount:snapshot.data.length，
itemBuilder：（上下文，outerIndex）{
返回列(
儿童：[
正文(
snapshot.data[outerIndex].name，
),
StreamBuilder(
流：snapshot.data[outerIndex].orderedFoodItemList，
生成器：（上下文，内部快照）{
if（innersapshot.data！=null）{
返回ListView.builder(
itemCount:innerSnapshot.data.length，
itemBuilder：（上下文，内部索引）{
返回列(
儿童：[
正文(
innerSnapshot.data[innerIndex].foodItemName
),
正文(
innerSnapshot.data[innerIndex].foodItemPrice
),
正文(
innerSnapshot.data[innerIndex].foodItemQuantity
),
],
);
},
);
}否则{
返回循环ProgressIndicator（）；
}
},
),
],
);
},
);
}否则{
返回文本（“无数据”）；
}
},
),

将子集合的名称更改为您知道的名称，而不是随机生成的ID。随着应用程序的增长，这将使现在和将来的安静变得更容易，而且更具成本效益。您的父集合当前命名为

bonapetite

，您有随机文档ID，然后在其子集合中，使用类似

Breaken

或

orders

，您可以稍后查询这些集合，因为您有原始的

docId

，即

集合（“bonapetite”）.doc（“docId”）.collection（“Breaken”）.get（）

StreamBuilder<List<Order>>(
        stream: DatabaseService(uid: FirebaseAuth.instance.currentUser.uid).getPendingOrdersList,
        builder: (context, snapshot){
          if(snapshot.data != null){
            return ListView.builder(
              itemCount: snapshot.data.length,
              itemBuilder: (context, outerIndex){
                return Column(
                  children: [
                    Text(
                      snapshot.data[outerIndex].name,
                    ),
                    StreamBuilder<List<OrderedFoodItem>>(
                      stream: snapshot.data[outerIndex].orderedFoodItemList,
                      builder: (context,innerSnapshot){
                        if(innerSnapshot.data != null){
                          return ListView.builder(
                            itemCount: innerSnapshot.data.length,
                            itemBuilder: (context, innerIndex) {
                              return Column(
                                children: [
                                  Text(
                                    innerSnapshot.data[innerIndex].foodItemName
                                  ),
                                  Text(
                                      innerSnapshot.data[innerIndex].foodItemPrice
                                  ),
                                  Text(
                                      innerSnapshot.data[innerIndex].foodItemQuantity
                                  ),
                                ],
                              );
                            },
                          );
                        } else {
                          return CircularProgressIndicator();
                        }
                      },
                    ),
                  ],
                );
              },
            );
          }else{
            return Text('no data');
          }

        },
      ),