带firebase查询的多关系颤振块

因此，我有一个firebase查询，其中：

用户

文档-具有

点的id数组

posts

collection-有多个

post

文档，每个post都有一个“spotId”

spot

集合-具有多个具有唯一id OBV的

spot

文档

现在，为了只向用户显示该用户关注的帖子，我必须：
迭代用户“点数组”（他跟随的点）。然后，对于该数组中的每个

spot id

，我必须对

posts

集合进行firebase查询，其中“spotId”==此id。因此，当我只有那些与spot用户相关的帖子时，我必须对

spot

集合进行另一次firebase查询，以获取用于后期显示的特定spot数据

方法如下所示：

@override
  Stream<List<Future<Post>>> posts(List userFollowedSpots) {
    final listOfStreams = userFollowedSpots.map((id) {
      return postCollection
          .where("spotId", isEqualTo: id)
          .snapshots()
          .map((snapshot) {
        return snapshot.documents.map((doc) {
          return spotCollection.document(doc.data["spotId"]).get().then((ds) {
            return Post.fromEntity(PostEntity.fromSnapshot(doc, ds));
          });
        }).toList();
      });
    });

    return StreamGroup.merge(listOfStreams); // <-- have to merge it as mapped userFollowedSpots returns Iterable<Stream...>>>>
  }

Stream<PostsState> _mapLoadPostToState(LoadPosts event) async* {
    List<Post> allPosts = [];
    _postsSubscription?.cancel();
    if (event.userFollowedSpots != null && event.userFollowedSpots.length > 0) {
      _postsSubscription =
          _postRepository.posts(event.userFollowedSpots).listen((posts) {
        Future.wait(posts).then((waitedPosts) {

          if (allPosts.length > 0) {
            allPosts = allPosts + waitedPosts;
          } else {
            allPosts = waitedPosts;
          }
          add(PostUpdated(allPosts));
        });
      });
    }
  }

@覆盖
流帖子（列出userfollowdspot）{
流的最终列表=userFollowedSpots.map（（id）{
返回后收集
.其中（“spotId”，isEqualTo:id）
.快照（）
.map（（快照）{
返回snapshot.documents.map（（doc）{
返回spotCollection.document（doc.data[“spotId”]）.get（），然后（（ds）{
返回Post.fromEntity（PostEntity.fromSnapshot（doc，ds））；
});
}).toList（）；
});
});
返回StreamGroup.merge（流列表）；/>
}

然后我就这样使用它：

@override
  Stream<List<Future<Post>>> posts(List userFollowedSpots) {
    final listOfStreams = userFollowedSpots.map((id) {
      return postCollection
          .where("spotId", isEqualTo: id)
          .snapshots()
          .map((snapshot) {
        return snapshot.documents.map((doc) {
          return spotCollection.document(doc.data["spotId"]).get().then((ds) {
            return Post.fromEntity(PostEntity.fromSnapshot(doc, ds));
          });
        }).toList();
      });
    });

    return StreamGroup.merge(listOfStreams); // <-- have to merge it as mapped userFollowedSpots returns Iterable<Stream...>>>>
  }

Stream<PostsState> _mapLoadPostToState(LoadPosts event) async* {
    List<Post> allPosts = [];
    _postsSubscription?.cancel();
    if (event.userFollowedSpots != null && event.userFollowedSpots.length > 0) {
      _postsSubscription =
          _postRepository.posts(event.userFollowedSpots).listen((posts) {
        Future.wait(posts).then((waitedPosts) {

          if (allPosts.length > 0) {
            allPosts = allPosts + waitedPosts;
          } else {
            allPosts = waitedPosts;
          }
          add(PostUpdated(allPosts));
        });
      });
    }
  }

Stream\u mapLoadPostToState（LoadPosts事件）异步*{
列出所有帖子=[]；
_订阅后？.cancel（）；
if（event.userFollowedSpots！=null&&event.userFollowedSpots.length>0）{
_认购后=
_postRepository.posts（event.userFollowedSpots）.listen（（posts）{
Future.wait（posts）.then（（waitedPosts）{
如果（allPosts.length>0）{
allPosts=allPosts+waitedPosts；
}否则{
allPosts=等待的posts；
}
添加（假定更新（所有职位））；
});
});
}
}

问题是：这有意义吗？因为看起来有点像黑客。通常，我希望这个

posts

方法有一个流，但有一件事：当我监听这个

post

方法蒸汽时，Firebase将为ID数组中的每个ID返回新的

事件。因此，如果数组将是[“1”，“2”]，那么
Future.wait（posts）。然后（（waitedPosts）
将为“1”返回post，然后为“2”返回post

这就是为什么我做了这个奇怪的黑客——我开始与Flatter_bloc合作，所以不知道这是黑客还是可以接受的解决方案

有人能提供意见吗？
如果你想同时提供所有结果，那么你应该使用
Future.wait
方法，它会将你的
List
更改为
Future
在这种情况下，Future.wait将解决
userfolloweredspots
项所拥有的时间-我猜这是firebase快照这就是为什么我做了这个奇怪的“命令式”把戏，在
列表allPosts=[]；