📑 firestore database 접근 및 삭제 code, firestore Queries 🍎

 

 

 

 

 

https://hello-developer.tistory.com/52

https://hello-developer.tistory.com/53?category=951601 

https://velog.io/@leesangsu200/Firestore에서-데이터-가져오기 

https://github.com/DeveloperAcademy-POSTECH/MC3-Team3-Puhaha

GitHub - DeveloperAcademy-POSTECH/MC3-Team3-Puhaha: 밥 먹언? : 부모와 자녀 간 식사사진을 공유할 수 있는 앱

https://firebase.google.com/docs/firestore/query-data/queries

 

 

 

 

 

 

- error handling

   db.collection("users").addDocument(data: [:]) { error in
       // this code is run after the operation is complete
       if error == nil {
           // operation success
       } else {
           // error, do something
       }
   }

 

 

 

 

 

 

 

- db에 data를 넣는 함수 (write)

    func setUserName(userIdentifier: String, userName: String) {
        db.collection("Users").document(userIdentifier).updateData(["name": userName])
    }
    
    func setDefaultUserData(userIdentifier: String) {
        db.collection("Users").document(userIdentifier).setData(["familyCode": "",
                                                            "name": "",
                                                            "pokeState": ["pokedBy": "",
                                                                          "pokedtime": ""],
                                                            "pokingTool": ["color": "",
                                                                           "tool": ""]])
    }

 

.setData() : 초기에 data를 set 할 때 사용 (덮어쓰기 주의)

.updateData() : 기존 필드의 값을 update 할 때 사용

 

db.collection("users").document("documentPath").delete()

-> 해당 path의 문서가 통으로 지워짐

db.collection("users").document("documentPath").updateData(["name": FieldValue.delete()])

-> 특정 필드의 값만 지워짐

 

 

 

 

 

 

- db에서 data를 가져오는 함수 (read)

    func getSignInUser(userIdentifier: String, completion: @escaping () -> Void) {
        loginedUser = User(accountId: userIdentifier)
        
        db.collection("Users").document(userIdentifier).addSnapshotListener { [self] (document, error) in
            if let document = document {
                let name = document.data()?["name"] as? String ?? ""
                let familyCodes = document.data()?["familyCode"] as? [String] ?? []
                let pokingTool = document.data()?["pokingTool"] as? [String: String] ?? [:]
                let pokeStateValue = document.data()?["pokeState"] as? [String: String] ?? [:]
                
                let pokingToolColor: String = pokingTool["color"]?.lowercased() ?? ""
                let pokingToolType: String = pokingTool["tool"]?.lowercased() ?? ""
                let toolImage: UIImage = UIImage(named: "\(pokingToolColor)_\(pokingToolType)") ?? UIImage()
                let pokedBy: String = pokeStateValue["pokedBy"] ?? ""
                let pokedTime: String = pokeStateValue["pokedTime"] ?? ""
                
                loginedUser.setName(name: name)
                loginedUser.setToolImage(toolImage: toolImage)
                loginedUser.setToolType(with: pokingToolType)
                loginedUser.setToolColor(with: pokingToolColor)
                loginedUser.setFamilyCodes(code: familyCodes)
                loginedUser.setPoke(poke: Poke(pokedBy: pokedBy, pokedTime: pokedTime))
                
                completion()
                
            } else {
                print(error ?? "")
            }
        }
    }

- escaping closure로 값을 가져오는 경우

: 단순히 서버의 data만 가져오는 경우에는 getDocument를 활용하면 된다.

-> but, UI를 그리는 과정에서 data가 불러온 뒤, 화면을 그려야 하는 경우에는

     completion handler를 활용하여 처리한다. 

 

 

 

 

 

 

1) 특정 document 를 조회하기 (pull) 

 

db.collection("users").document("documentPath").getDocument { (snapshot, error) in
    if error == nil && snapshot != nil && snapshot!.data() != nil {
        print(snapshot!.data()
    }
}

: collection 내부의 특정 document 에서 getDocument

 

 

 

 

2) collection 내부의 모든 document 조회하기 (pull) 

db.collection("users").getDocuments { (snapshot, error) in
    if error == nil && snapshot != nil {
        for document in snapshot!.documents {
            print(document.documentID)
        }
    } else {
    // error. do something
    }
}

: collection에서 getDocuments 

 

 

 

 

3) 특정 document 를 조회하기 (push)

pull: 원래는 db의 data를 그냥 받아옴 -> push: database 상의 변화가 생겼을 때, data를 보내주는 것

let listener = db.collection("users").document("documentPath").addSnapshotListener { (snapshot, error) in
    if error == nil && snapshot != nil && snapshot!.data() != nil {
        print(snapshot!.data())
    }
}

: 서버에서 변화하는 data를 알아야할 때 사용 (addSnapshotListener 리스너를 추가하여, 업데이트 사항을 수신)

 

 

 

 

4) collection 내부의 모든 documents 조회 (push)

let listener = db.collection("users").addSnapshotListener { (snapshot, error) in
    if error == nil && snapshot != nil {
        // 변화가 있는것만 가져올 수 있다.
        for change in snapshot!.documentChanges {
            print(change.document.documentID)
        }
    } else {
        // error. do something
    }
}

출처: https://hello-developer.tistory.com/53?category=951601 

: 모든 문서를 돌지 않고, 변화가 생긴 값만 가져올 때 change 활용

 

 

 

 

 

 

 

 

- Firestore Queries

: whereField를 통해 원하는 조건의 data를 가져올 수 있다!

: google firebase 공식문서 참조 https://firebase.google.com/docs/firestore/query-data/queries#compound_queries

let query = db.collection("users").whereField("age", isEqualTo: 30)

query.getDocuments { (snapshot, error) in
    
    let docs = snapshot!.documents

    for doc in docs {
        print(doc.documentID)
    }
}

 

 

 

// Create a reference to the cities collection
let citiesRef = db.collection("cities")

// Create a query against the collection.
let query = citiesRef.whereField("state", isEqualTo: "CA")

let capitalCities = db.collection("cities").whereField("capital", isEqualTo: true)

- 1) 주가 "CA"인 도시들을 반환, 2) 수도인 도시(capital이 true인)들을 반환

 

 

 

 

db.collection("cities").whereField("capital", isEqualTo: true).getDocuments() { (querySnapshot, err) in
    if let err = err {
        print("Error getting documents: \(err)")
    } else {
        for document in querySnapshot!.documents {
            print("\(document.documentID) => \(document.data())")
        }
    }
}

-> whereField 까지가 쿼리 객체 생성 -> get 함수를 사용하여 특정 조건을 만족하는 데이터 가져오기

 

 

 

 

 

사용 가능한 쿼리 연산자들 (조건 검색 시) : 공식 문서에 예제와 함께 잘 정리되어 있다.

 

 

 

 

 

- array 쿼리

1) in

let citiesRef = db.collection("cities")

citiesRef.whereField("country", in: ["USA", "Japan"])

-> country 필드 값이 USA 이거나 Japan인 모든 문서를 반환한다. (ex) 샌프란시스코, 로스엔젤레스, 토교, 

 

 

 

 

2) not-in

citiesRef.whereField("country", notIn: ["USA", "Japan"])

-> country 필드가 존재하되, USA or Japan은 아니며, 또한 빈 값도 아니어야 함!

: 그런 모든 cities collection의 문서를 반환한다.

 

: 주의사항 있으니 공식문서에서 더 읽어보자.

not-in 쿼리는 지정된 필드가 없는 문서를 제외합니다. 빈 문자열(""), null, NaN(숫자 아님)을 포함하는 어떤 값으로든 설정되면 필드가 존재합니다. x != null은 undefined로 평가됩니다. null을 비교 값 중 하나로 가지고 있는 not-in 쿼리는 어떤 문서와도 일치하지 않습니다.

 

 

 

 

3) array-contains-any

let citiesRef = db.collection("cities")
citiesRef.whereField("regions", arrayContainsAny: ["west_coast", "east_coast"])

- regions 필드는 west_coast 또는 east_coast가 포함된 배열

- 중복되는 array-contains-any의 결과가 삭제

- array-contains-any: 항상 배열 데이터 유형 기준으로 필터링: 배열 대신 regions 필드가 west_coast 문자열인 city 문서는 X

: 단순히 값 만의 비교는 In을 사용하고, 배열 내부의 데이터에 대한 접근은 array-contains-any 사용!

 

 

 

 

 

 

 

- 복합 쿼리

: 여러 등호 연산자를 통해, 구체적인 조건을 걸 수 있다. -> 복합 쿼리를 만들 수 있음

citiesRef
    .whereField("state", isEqualTo: "CO")
    .whereField("name", isEqualTo: "Denver")
    
citiesRef
    .whereField("state", isEqualTo: "CA")
    .whereField("population", isLessThan: 1000000)

 

필드 1개에서만 범위 필터 사용하는 것이 올바른 사용! (범위 필터란 -> isLessThan 이런 연산! 부등호 연산들!)

 

 

 

 

citiesRef
    .whereField("state", isGreaterThanOrEqualTo: "CA")
    .whereField("population", isGreaterThan: 1000000)

잘못된 사용! 여러 필드에 범위 필터 사용 (필터: , 뒤에 붙는 것으로 이해)

 

 

 

 

 

 

 

 

 

[ MC2 project에서 활용한 예시 ]

 

//  User.swift

import UIKit

class User {
    private let accountId: String?
    private var name: String?
    private var loginForm: Int?

    private var toolImage: UIImage?
    private var toolType: String?
    private var toolColor: String?
    private var familyCodes: [String?]
    private var pokeState: Poke?
    
    init() {
        self.accountId = nil
        self.name = nil
        self.loginForm = 0

        self.toolImage = nil
        self.toolType = nil
        self.toolColor = nil
        self.familyCodes = []
        self.pokeState = nil
    }
    
    init(accountId: String) {
        self.accountId = accountId
        self.name = nil
        self.loginForm = 0

        self.toolImage = nil
        self.toolType = nil
        self.toolColor = nil
        self.familyCodes = []
        self.pokeState = nil
    }

    init(accountId: String, name: String) {
        self.accountId = accountId
        self.name = name
        self.loginForm = 0

        self.toolImage = nil
        self.toolType = nil
        self.toolColor = nil
        self.familyCodes = []
        self.pokeState = nil
    }

    init(accountId: String, name: String, toolImage: UIImage, toolType: String, toolColor: String, familyCodes: [String], pokeState: Poke) {
        
        self.accountId = accountId
        self.name = name
        self.loginForm = 0

        self.toolImage = toolImage
        self.toolType = toolType
        self.toolColor = toolColor
        self.familyCodes = familyCodes
        self.pokeState = pokeState
    }
    
    public func setName(name: String) {
        self.name = name
    }
    public func getName() -> String {
        return name ?? ""
    }

    public func setToolImage(toolImage: UIImage) {
        self.toolImage = toolImage
    }
    public func getToolImage() -> UIImage {
        return toolImage ?? UIImage()
    }
    
    public func setToolType(with tool: String) {
        self.toolType = tool
    }
    public func getToolType() -> String {
        return toolType ?? ""
    }
    
    public func setToolColor(with color: String) {
        self.toolColor = color
    }
    public func getToolColor() -> String {
        return toolColor ?? ""
    }
    
    public func setPoke(poke: Poke) {
        self.pokeState = poke
    }
}

 

 

 

//  FirestoreManager.swift

import UIKit

import FirebaseFirestore
import FirebaseFirestoreSwift

class FirestoreManager: ObservableObject {
    private let tagColor: [UIColor] = [.customPurple, .customBlue, .customGreen]
    
    private var db = Firestore.firestore()
    
    @Published var meals: [Meal]
    @Published var user: User
    @Published var loginedUser: User
    @Published var userIdentifiers: [String]
    @Published var families: [Family]
    @Published var documentsCount = 0
    @Published var isExistFamily: Bool
    
    init() {
        self.meals = []
        self.user = User()
        self.loginedUser = User()
        self.userIdentifiers = []
        
        self.families = [Family(user: User(accountId: "",
                                           name: "모두",
                                           toolImage: UIImage(named: "IconEveryoneFilter")!,
                                           toolType: "",
                                           toolColor: "",
                                           familyCodes: [String()],
                                           pokeState: Poke()),
                                isSelected: true)]
        
        self.isExistFamily = false
    }
    
    func fetchMeals(familyCode: String, date: Date?, completion: @escaping () -> Void) {
        var documentPath: Query = db.collection("Families").document(familyCode).collection("Meals")
        
        if date != nil {
            documentPath = documentPath.whereField("uploadDate", isEqualTo: date!.dateText)
        }
        
        documentPath.order(by: "uploadTime", descending: true).addSnapshotListener { [self] (querySnapshot, _) in
            guard let documents = querySnapshot?.documents else {
                print("No Documents")
                return
            }
            
            meals = documents.map { (queryDocumentSnapshot) -> Meal in
                let data = queryDocumentSnapshot.data()
                
                let mealImageIndex = data["mealImageIndex"] as? String ?? ""
                let tagsString = data["tags"] as? [String: String] ?? [:]
                var tags: [Tag] = []
                for key in tagsString.keys {
                    tags.append(Tag(content: tagsString[key] ?? "", backgroundColor: self.tagColor[Int(key) ?? 0]))
                }
                
                let userIdentifier = data["uploadUser"] as? String ?? ""
                let uploadedTime = data["uploadTime"] as? String ?? ""
                let uploadedDate = data["uploadDate"] as? String ?? ""
                let reactionsValue = data["reactions"] as? [[String: String]] ?? []
                var reactions: [Reaction?] = [nil]
                for i in 0..<reactionsValue.count {
                    for key in reactionsValue[i].keys {
                        reactions.append(Reaction(reactionEmojiString: reactionsValue[i][key]!, reactedUserName: key))
                    }
                }
                
                let meal = Meal(mealImage: UIImage(), mealImageName: mealImageIndex, uploadUser: "", userIdentifier: userIdentifier, userIcon: UIImage(), tags: tags, uploadedDate: uploadedDate, uploadedTime: uploadedTime, reactions: reactions)
                
                DispatchQueue.main.async {
                    completion()
                }
                
                return meal
            }
        }
    }
    
    func getUploadUser(userIdentifier: String, completion: @escaping () -> Void) {
        user = User(accountId: userIdentifier)
        
        db.collection("Users").document(userIdentifier).addSnapshotListener { [self] (document, error) in
            if let document = document {
                let name = document.data()?["name"] as? String ?? ""
                let familyCodes = document.data()?["familyCode"] as? [String] ?? []
                let pokingTool = document.data()?["pokingTool"] as? [String: String] ?? [:]
                let pokeStateValue = document.data()?["pokeState"] as? [String: String] ?? [:]
                
                let pokingToolColor: String = pokingTool["color"]?.lowercased() ?? ""
                let pokingToolTool: String = pokingTool["tool"]?.lowercased() ?? ""
                let toolImage: UIImage = UIImage(named: "\(pokingToolColor.lowercased())_\(pokingToolTool)") ?? UIImage()
                
                /* Tool enum 사용할 경우
                let toolType = convertStringToToolType(string: pokingTool["tool"] ?? "")
                let toolColor = convertStringToToolColor(string: pokingTool["color"] ?? "")
                let toolImage: UIImage = UIImage(named: "\(toolColor)_\(toolType.imageFileName)") ?? UIImage()
                */
                
                let pokedBy: String = pokeStateValue["pokedBy"] ?? ""
                let pokedTime: String = pokeStateValue["pokedTime"] ?? ""
                
                user.setName(name: name)
                user.setToolImage(toolImage: toolImage)
                user.setToolType(with: pokingToolTool)
                user.setToolColor(with: pokingToolColor)
                user.setFamilyCodes(code: familyCodes)
                user.setPoke(poke: Poke(pokedBy: pokedBy, pokedTime: pokedTime))
                completion()
            } else {
                print(error ?? "")
            }
        }
    }
    
    func getSignInUser(userIdentifier: String, completion: @escaping () -> Void) {
        loginedUser = User(accountId: userIdentifier)
        
        db.collection("Users").document(userIdentifier).addSnapshotListener { [self] (document, error) in
            if let document = document {
                let name = document.data()?["name"] as? String ?? ""
                let familyCodes = document.data()?["familyCode"] as? [String] ?? []
                let pokingTool = document.data()?["pokingTool"] as? [String: String] ?? [:]
                let pokeStateValue = document.data()?["pokeState"] as? [String: String] ?? [:]
                
                let pokingToolColor: String = pokingTool["color"]?.lowercased() ?? ""
                let pokingToolType: String = pokingTool["tool"]?.lowercased() ?? ""
                let toolImage: UIImage = UIImage(named: "\(pokingToolColor)_\(pokingToolType)") ?? UIImage()
                let pokedBy: String = pokeStateValue["pokedBy"] ?? ""
                let pokedTime: String = pokeStateValue["pokedTime"] ?? ""
                
                loginedUser.setName(name: name)
                loginedUser.setToolImage(toolImage: toolImage)
                loginedUser.setToolType(with: pokingToolType)
                loginedUser.setToolColor(with: pokingToolColor)
                loginedUser.setFamilyCodes(code: familyCodes)
                loginedUser.setPoke(poke: Poke(pokedBy: pokedBy, pokedTime: pokedTime))
                
                completion()
                
            } else {
                print(error ?? "")
            }
        }
    }
    
    func getFamilyMember(familyCode: String, completion: @escaping () -> Void) {
        db.collection("Families").document(familyCode).addSnapshotListener { [self] (document, error) in
            if let document = document {
                let userIdentifier: [String] = document.data()?["users"] as? [String] ?? []
                userIdentifiers = userIdentifier
                db.collection("Users").whereField("familyCode", isEqualTo: familyCode).addSnapshotListener { [self] (querySnapshot, _) in/*.getDocuments(source: .default) { [self] (querySnapshot, error) in*/
                    if let error = error {
                        print("Error getting documents: \(error)")
                    } else {
                        families = [Family(user: User(accountId: "",
                                                      name: "모두",
                                                      toolImage: UIImage(named: "IconEveryoneFilter")!,
                                                      toolType: "",
                                                      toolColor: "",
                                                      familyCodes: [String()],
                                                      pokeState: Poke()),
                                           isSelected: true)]
                        for document in querySnapshot!.documents {
                            let data = document.data()
                            
                            let accountId = data["accountId"] as? String ?? ""
                            let name = data["name"] as? String ?? ""
                            /* 안드로이드 개발이 되는 경우 0: 애플 계정 로그인, 1: 구글 계정 로그인으로 사용 예정
                            let loginForm = data["loginForm"] as? Int ?? 0
                            */
                            let familyCodes = data["familyCode"] as? [String] ?? []
                            let pokingTool = data["pokingTool"] as? [String: String] ?? [:]
                            let pokeStateValue = data["pokeState"] as? [String: String] ?? [:]
                            
                            let pokingToolColor: String = pokingTool["color"]?.lowercased() ?? ""
                            let pokingToolTool: String = pokingTool["tool"]?.lowercased() ?? ""
                            let toolImage: UIImage = UIImage(named: "\(pokingToolColor)_\(pokingToolTool)") ?? UIImage()
                            let pokedBy: String = pokeStateValue["pokedBy"] ?? ""
                            let pokedTime: String = pokeStateValue["pokedTime"] ?? ""
                            
                            let user = User(accountId: accountId,
                                            name: name,
                                            toolImage: toolImage,
                                            toolType: pokingToolTool,
                                            toolColor: pokingToolColor,
                                            familyCodes: familyCodes,
                                            pokeState: Poke(pokedBy: pokedBy, pokedTime: pokedTime))
                            
                            families.append(Family(user: user, isSelected: false))
                        }
                        completion()
                    }
                }
            } else {
                print(error ?? "")
            }
        }
    }
    
    func setPokingToolData(userIdentifier: String, tool passedTool: PokeTool) {
        
        let tool = passedTool.tool.imageFileName
        let color = convertUIColorToString(color: passedTool.color)
        
        db.collection("Users").document(userIdentifier).updateData([
            "pokingTool.tool": tool,
            "pokingTool.color": color
        ])
    }
    
    func addReaction(familyCode: String, meal: Meal, newReaction: [String: String]) {
        db.collection("Families").document(familyCode).collection("Meals").whereField("uploadUser", isEqualTo: meal.userIdentifier).whereField("uploadDate", isEqualTo: meal.uploadedDate).whereField("uploadTime", isEqualTo: meal.uploadedTime).getDocuments { querySnapshot, error in
            if let error = error {
                print("Error getting documents: \(error)")
            } else {
                for document in querySnapshot!.documents {
                    let data = document.data()
                    
                    var reactions = data["reactions"] as? [[String: String]] ?? []
                    reactions.append(newReaction)
                    document.reference.updateData(["reactions": reactions])
                }
            }
        }
    }
    
    func setFamilyCode(userIdentifier: String, code: String) {
        db.collection("Users").document(userIdentifier).updateData(["familyCodes": [code]])
    }
    
    // TODO: 특정 코드를 지우기 위해 parameter로 code를 받아야 하나?
    func deleteFamilyCode(userIdentifier: String) {
        db.collection("Users").document(userIdentifier).updateData(["familyCodes": ""])
    }
    
    func setUserName(userIdentifier: String, userName: String) {
        db.collection("Users").document(userIdentifier).updateData(["name": userName])
    }
    
    func setDefaultUserData(userIdentifier: String) {
        db.collection("Users").document(userIdentifier).setData(["familyCode": "",
                                                            "name": "",
                                                            "pokeState": ["pokedBy": "",
                                                                          "pokedtime": ""],
                                                            "pokingTool": ["color": "",
                                                                           "tool": ""]])
    }
    
    func isExistFamily(roomCode: String, completion: @escaping () -> Void) {
        db.collection("Families").document(roomCode).getDocument { document, error in
            let isExist = document?.exists ?? false
            self.isExistFamily = isExist
            completion()
        }
    }
    
    func setUpMeals(image: UIImage,
                    userIdentifier: String,
                    familyCode: String,
                    tags: [String]) {
        let today = Date.now
        
        let documentRef = db.collection("Families").document(familyCode).collection("Meals")
        let storageManager = StorageManager()
        let imageName: String = "img_\(today.dateText)_\(today.timeNumberText)\(today.secondsText()).jpeg"
        
        storageManager.uploadMealImage(image: image, familyCode: familyCode, imageName: imageName) {
            documentRef.addDocument(data: [
                "mealImageIndex": imageName,
                "uploadUser": userIdentifier,
                "uploadDate": Date().dateText,
                "uploadTime": Date().timeNumberText,
                "tags": ["0": tags[0],
                         "1": tags[1],
                         "2": tags[2]
                        ],
                "reactions": []])
        }
        print("이미지이름: \(imageName)")
    }