Firebase to array - wait for all Data before do next function

Question

Okay, after some comments for more information to this question, let's try it:

In a viewController I'm calling a function loadPosts(). In this function I'm calling api.shared.function observePosts(). observePosts() downloads all posts at a specified database reference. with the first downloaded post back in the loadPosts() I'm calling self.fetchUser(uid: post.uid) in VC. This call api.shared.function observeUser() which gives me the user from the current post downloaded.

In observeUser() I'm filling users-array with user-object from type UserModel and in completion-block of loadPosts() I'm filling posts-array with post-object from type PostModel. After insert the post to posts-array at:0 I reload the tableView and get a view of all downloaded posts with matching info about the user that created it. (code comes after description)

Means: If there are 5 posts from type PostModel - there must be 5 userModel's, too. Every function is called 5 times - in this example with 5. Every function is running 5 times. (Tested with a print("call loadPosts")).

What I finally want is: Get the posts and the users - fill the arrays (when all posts at this time) are loaded. Make this step again - with posts2 and users2. If all four arrays are filled - an algorithm get them together in one posts-array and one users-array, like: post[0], post1, post[2], post2[0], post[3], post[4], post[5], post21 ... Of course the users will be putting together in one as well. THIS PART IS NO PROBLEM! I HAVE A WORKING CODE ... with hardcoded strings in the arrays

My problem is: When I'm calling a function at the end of a function it can be fact that the asynchronous task of loading the posts ( users ) is not done. So, how can I make the code "wait to complete"? I have tried this from StackOverflow and also tried to work with DispatchQueue but that don't work, too.

Before the code is coming - here is my workaround: xCode 11.3.1 with Swift 5. ( async / await - solutions from the comments are not possible )

Code(s): In ViewController:

viewDidLoad => loadPosts()

loadPosts(){
  Api.shared.observePosts { (post) in
    self.fetchUser(uid: UserUid, completed:{
      self.posts.insert(post, at:0)
      self.tableView.reloadData()
    })
  }
}
func fetchUser(uid: String, completed: @escaping () -> Void) {
      Api.shared.observeUser(uid: uid) { (user) in
          self.users.insert(user, at: 0)
          completed()
      } 
  } 

In Api

// load posts
  func observePosts(completion: @escaping (PostModel) -> Void){
      REF_POSTS.observe(.childAdded) { (snapshot) in
          guard let dic = snapshot.value as? [String: Any] else { return }
          let newPost = PostModel(dictionary: dic, key: snapshot.key)
          completion(newPost)
      } 
  } 
// load users
func observeUser(uid: String, completion: @escaping(UserModel) -> Void){
      REF_USERS.child(uid).observeSingleEvent(of: .value) { (snapshot) in
          guard let dic = snapshot.value as? [String: Any] else { return }
          let newUser = UserModel(dictionary: dic)
          completion(newUser)
      } 
  }

I hope that now is clear what I'm doing and what I want to to after modifying the code. Any help or info is welcome.

Answer 1

The question is a bit vague but what I think is being asked is:

I have two Firebase nodes (collections in Firestore), a post node and a user node. The post node contains child nodes that have a node that stores the uid of the user which are found in the users node. I want to load all the posts and the user associated with each post

If that's the question, here's a simplified solution:

First a structure to store the post and users name

struct PostAndUserStruct {
    var post = ""
    var userName = ""
}

and then a class var to use as a tableView dataSource

var postsAndUsersArray = [PostAndUserStruct]()

and then the code to read it in and populate that datasource for use with the tableView

func readPostsAndUser( completion: @escaping () -> Void ) {
    let postsRef = self.ref.child("posts")
    let usersRef = self.ref.child("users")

    postsRef.observeSingleEvent(of: .value, with: { snapshot in
        let allPosts = snapshot.children.allObjects as! [DataSnapshot]
        let lastPostIndex = allPosts.count - 1
        for (index, post) in allPosts.enumerated() {
            let postText = post.childSnapshot(forPath: "post_msg").value as? String ?? "No Msg"
            let uid = post.childSnapshot(forPath: "post_uid").value as? String ?? "No User"
            let thisUser = usersRef.child(uid)
            thisUser.observeSingleEvent(of: .value, with: { userSnapshot in
                let name = userSnapshot.childSnapshot(forPath: "name").value as? String ?? "No Name"
                let postAndUser = PostAndUserStruct(post: postText, userName: name)
                self.postsAndUsersArray.append(postAndUser)
                if index == lastPostIndex {
                    completion()
                }
            })
        }
    })
}

The flow code flow is

The postsAndUsersArray would be a tableView datasource.

Load all of the posts and cast the snapshot to an array to preserve ordering. Keep track of how many there are

Iterate over each post, capturing the post msg as well as the uid of the user that made the post.

Read each user, instantiate a PostAndUserStruct and add it to the class array (the tableViewDatasource)

When the loop gets to the last index, call the completion handler and output the results to console (good place to reload the tableView)

and is called like this

func handleButton0Action() {
    self.readPostsAndUser(completion: {
        for post in self.postsAndUsersArray {
            print(post.userName, post.post)
        }
        //this is a good place to reload the tableview
    })
}

The "note to self" on this is it's not super scaleable with large datasets but gets the job done for small dataset. If you have a millions posts you will need to implement pagination to read a chunk of posts at a time, otherwise you'll overload the device's memory and have random crashes.

NOTE: BELOW IS FIRESTORE CODE

The code to read the posts, read in the user for each post and return a populated array of PostAndUserStruct objects, noting self.db points to MY Firestore.

func readPostsAndUsersAsync() async -> [PostAndUserStruct] {
    let postsCollection = self.db.collection("posts")
    let usersCollection = self.db.collection("users")
    var postDataArray = [PostAndUserStruct]()

    let postSnapshot = try! await postsCollection.getDocuments()
    let allPosts = postSnapshot.documents

    for post in allPosts {
        let postText = post.get("post_msg") as? String ?? "No Post Message"
        if let uid = post.get("post_uid") as? String {
            let userDoc = usersCollection.document(uid)
            let userSnap = try! await userDoc.getDocument()
            let name = userSnap.get("name") as? String ?? "No Name"
            let postData = PostAndUserStruct(post: postText, userName: name)
            postDataArray.append(postData)
        }
    }

    return postDataArray
}

The code flow:

All of the documents are read from Firestore with getDocuments. Then we cast those documents to the allPosts array.

Iterate over the array, capturing the post_msg field from each post as well as the uid of the use that posted it.

Then, using the uid, read the users document from the users collection and get the users name.

Instantiate a PostAndUserStruct object with the post and users name and add it to an array.

Then return the populated array

That function is called like this and outputs the users name and post text to console.

func fetchPostsAndUsers() {
    Task {
        let postResults = await self.readPostsAndUsersAsync()
        for postAndUser in postResults {
            print(postAndUser.userName, postAndUser.post)
        }
    }

}