在 Firebase 中组织组 Swift 上的身份验证

Question

I am using Firebase authentication on Swift in Xcode. I want to create "groups" for the user login so that certain users will have access to certain data. For example, in my app, I want basketball players on the basketball team to only have access to the basketball stats. Does anyone know what this is called in Firebase and how to do it?

Answer 1

As mentioned, the user for the authentication (Auth user) is just the user for the authentication, it does not contain much more information. Please see the attached screenshot from Firebase (Authentication):

That is the reason why we have to add a new User struct (in the users collection) which provides all these kind of information (could be name, age, groups of something.... whatever). The user document needs a reference to the Auth user. In the example I am using the user uid (@frank-van-puffelen is that a common way to use the uid or does it cause safety relevant issues?)

One side note, since we only get the entire documents and sometimes a user could have some private data that must not be available for others, it may make sense to split the struct into PublicUser and PrivateUser.

Anyway, for this example, let's create a User struct in swift

User

//
//  User.swift
//  Firebase User
//
//  Created by Sebastian Fox on 18.08.22.
//

import Foundation
import SwiftUI
import Firebase

struct User: Codable, Identifiable, Hashable {
    
    var id: String?
    var name: String
    var group: SportType
    
    
    init(name: String, group: SportType, id: String?) {
        self.id = id
        self.name = name
        self.group = group
    }
    
    init?(document: QueryDocumentSnapshot) {
        let data = document.data()
        
        guard let name = data["name"] as? String else {
            return nil
        }
        
        guard let group = data["group"] as? SportType else {
            return nil
        }
        
        id = document.documentID
        self.name = name
        self.group = group
    }
    
    enum CodingKeys: String, CodingKey {
        case id
        case name
        case group
    }
}

extension User: Comparable {
    
    static func == (lhs: User, rhs: User) -> Bool {
        return lhs.id == rhs.id
    }
    
    static func < (lhs: User, rhs: User) -> Bool {
        return lhs.name < rhs.name
    }
}


// I also create an enum with sort types, this is not necessarily part of the User struct. To load it to the Firestone database it must be codable.

enum SportType: String, Codable, CaseIterable {
    case basektball = "Basketball"
    case baseball = "Baseball"
    case soccer = "Soccer"
    case chess = "Chess"
    case noSport = "No Sport"
}

Now, let's do the magic with the UserViewModel which contains the functions we call to work with Firebase (Firestore), eg signUp (here we are talking about the Auth user), signIn (Auth user again) or createNewUser (here it is our new user struct):

UserViewModel.swift

//
//  UserViewModel.swift
//  Firebase User
//
//  Created by Sebastian Fox on 18.08.22.
//

import Foundation
import FirebaseFirestore
import Firebase
import FirebaseFirestoreSwift

class UsersViewModel: ObservableObject {
    
    let db = Firestore.firestore()
    
    // Published and saved to local device
    @Published var users = [User]()
    
    // Sign Up
    func signUp(email: String, password: String, completion: @escaping (Bool, String)->Void) {
        
        Auth.auth().createUser(withEmail: email, password: password) { authResult, error in
            
            // ERROR AND SUCCESS HANDLING
            if error != nil {
                // ERROR HANDLING
                print(error?.localizedDescription as Any)
                completion(false, "ERROR")
            }
            // SUCCESS HANDLING
            completion(true, authResult?.user.uid ?? "")
        }
    }
    
    // Sign In
    func signIn(email: String, password: String, completion: @escaping (Bool)->Void) {
        
        Auth.auth().signIn(withEmail: email, password: password) { (authResult, error) in
            
            // ERROR AND SUCCESS HANDLING
            if error != nil {
                // ERROR HANDLING
                print(error?.localizedDescription as Any)
                completion(true)
            }
            // SUCCESS HANDLING
            completion(true)
        }
    }
    
    // Sign Out
    func signOut() {
        try! Auth.auth().signOut()
    }
    
    // Create new user
    func createNewUser(name: String, group: SportType, id: String) {
        do {
            let newUser = User(name: name, group: group, id: id)
            try db.collection("users").document(newUser.id!).setData(from: newUser) { _ in
                print("User \(name) created")
            }
        } catch let error {
            print("Error writing user to Firestore: \(error)")
        }
    }
    
    // FOR TESTING: Get a list of all users
    func fetchAllUsers(_ completion: @escaping (Bool) ->Void) {
        self.users = []
        db.collection("users").addSnapshotListener { (querySnapshot, error) in
            guard let documents = querySnapshot?.documents else {
                print("No documents")
                return
            }
            
            self.users = documents.map { queryDocumentSnapshot -> User in
                let data = queryDocumentSnapshot.data()
                let id = data["id"] as? String ?? ""
                let name = data["name"] as? String ?? ""
                let group = data["group"] as? String ?? ""
                return User(name: name, group: SportType(rawValue: group) ?? .noSport, id: id)
            }
            completion(true)
        }
    }
    
}

Now you have 2 options to signUp (the Auth user) AND create a new user (based on the new user struct):

1. You have 2 separate views, on the first view, the user signs up, that creates the Auth user. On the second view, which is only available after signing up, the user can add data like name, group or whatever you want. (I'd prefer this option)

2. You handle everything in one view. You are holding all necessary data, call the signUp function and when you get the completion response, you call the function to create the user.

One last thing, since you don't get that information from Auth.auth(), if you want to be able to change these data, you'll have to fetch the user data for that specific user from the Firestore database. Of course you can save these information as values to UserDefaults (storage) while you create a new user, later you can save that information when the user logs in.

Best, Sebastian