Add .removed logic for posts and getAllUserData()

Gauge/Feed/Models/Category.swift

@@ -15,51 +15,92 @@ enum Category {
     case relationships(Relationships)
     case other(Other)
 
-    enum Sports: String {
+    enum Sports: String, CaseIterable {
         case nfl = "NFL"
         case collegeFootball = "College Football"
         case mlb = "MLB"
     }
 
-    enum Entertainment: String {
+    enum Entertainment: String, CaseIterable {
         case movies = "Movies"
         case tvShows = "TV Shows"
     }
 
-    enum Educational: String {
+    enum Educational: String, CaseIterable {
         case cs = "Computer Science"
         case math = "Math"
         case environment = "Environment"
         case health = "Health & Fitness"
     }
 
-    enum News: String {
+    enum News: String, CaseIterable {
         case politics = "Politics"
         case business = "Business"
     }
 
-    enum Lifestyle: String {
+    enum Lifestyle: String, CaseIterable {
         case fashion = "Fashion"
         case beauty = "Beauty"
         case travel = "Travel"
     }
 
-    enum Arts: String {
+    enum Arts: String, CaseIterable {
         case music = "Music"
         case artwork = "Artwork"
     }
 
-    enum Relationships: String {
+    enum Relationships: String, CaseIterable {
         case dating = "Dating"
         case relationships = "Relationships"
         case parenting = "Parenting"
     }
 
-    enum Other: String {
+    enum Other: String, CaseIterable {
         case funny = "Funny"
         case jokes = "Jokes"
     }
 
+    static var allCases: [Category] {
+        return Sports.allCases.map(Category.sports) +
+               Entertainment.allCases.map(Category.entertainment) +
+               Educational.allCases.map(Category.educational) +
+               News.allCases.map(Category.news) +
+               Lifestyle.allCases.map(Category.lifestyle) +
+               Arts.allCases.map(Category.arts) +
+               Relationships.allCases.map(Category.relationships) +
+               Other.allCases.map(Category.other)
+    }
+
+    static var allCategoryStrings: [String] {
+        return allCases.map { $0.rawValue }
+    }
+
+    static func mapStringsToCategories(returnedStrings: [String]) -> [Category] {
+        var categories: [Category] = []
+
+        for string in returnedStrings {
+            if let sportsCategory = Category.Sports(rawValue: string) {
+                categories.append(.sports(sportsCategory))
+            } else if let entertainmentCategory = Category.Entertainment(rawValue: string) {
+                categories.append(.entertainment(entertainmentCategory))
+            } else if let educationalCategory = Category.Educational(rawValue: string) {
+                categories.append(.educational(educationalCategory))
+            } else if let newsCategory = Category.News(rawValue: string) {
+                categories.append(.news(newsCategory))
+            } else if let lifestyleCategory = Category.Lifestyle(rawValue: string) {
+                categories.append(.lifestyle(lifestyleCategory))
+            } else if let artsCategory = Category.Arts(rawValue: string) {
+                categories.append(.arts(artsCategory))
+            } else if let relationshipsCategory = Category.Relationships(rawValue: string) {
+                categories.append(.relationships(relationshipsCategory))
+            } else if let otherCategory = Category.Other(rawValue: string) {
+                categories.append(.other(otherCategory))
+            }
+        }
+
+        return categories
+    }
+
     var rawValue: String {
         switch self {
         default:

Gauge/Feed/ViewModels/PostFirebase.swift

@@ -75,7 +75,7 @@ class PostFirebase: ObservableObject {
                 } else if change.type == .modified {
 
                 } else if change.type == .removed {
-
+                    self.allQueriedPosts = self.allQueriedPosts.filter { $0.postId != change.document.documentID }
                 }
             }
         }
@@ -301,6 +301,105 @@ class PostFirebase: ObservableObject {
         }
     }
 
+    // Currently only works for Binary & Slider posts
+    func getResponses(postId: String, completion: @escaping ([String: Int]) -> Void){
+        var responses: [String: Int] = [:]
+
+        Firebase.db.collection("POSTS").document(postId).collection("RESPONSES").getDocuments { (snapshot, error) in
+            if let error = error{
+                print("Error getting Post data: \(error)")
+            } else {
+                for document in snapshot!.documents {
+                    let data = document.data()
+
+                    if responses.keys.contains(data["responseOption"] as! String){
+                        responses[data["responseOption"] as! String]! += 1
+                    } else {
+                        responses[data["responseOption"] as! String] = 1
+                    }
+                }
+
+                completion(responses)
+            }
+        }
+    }
+
+    func suggestPostCategories(question: String, responseOptions: [String], completion: @escaping (([Category]) -> Void)) {
+        let categories: [String] = Category.allCategoryStrings
+
+        let systemPrompt = """
+            You are a classifier that assigns categories to a post based on 
+            a post's question and its responses. 
+            Only respond with valid categories from the provided list. 
+            Do not create new categories. Return the answer as a JSON array.
+            """
+
+        let userPrompt = """
+            Question: \(question)
+            Response Options: \(responseOptions.joined(separator: ", "))
+            Valid Categories: \(categories.joined(separator: ", "))
+
+            Provide the category list as a JSON array without using any
+            markdown or coding blocks, just the raw string value.
+            """
+
+        let parameters: [String: Any] = [
+           "model": "gpt-4o-mini",
+           "messages": [
+                ["role": "system", "content": systemPrompt],
+                ["role": "user", "content": userPrompt]
+           ],
+           "temperature": 0.2
+        ]
+
+        guard let url = URL(string: "https://api.openai.com/v1/chat/completions") else {
+            print("Invalid URL")
+            return
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.setValue("Bearer \(Keys.openAIKey)", forHTTPHeaderField: "Authorization")
+
+        do {
+            print("body created")
+            request.httpBody = try JSONSerialization.data(withJSONObject: parameters, options: [])
+        } catch {
+            print("Error serializing request body: \(error)")
+            return
+        }
+
+        URLSession.shared.dataTask(with: request) { data, response, error in
+            if let error = error {
+                print("Error querying OpenAI: \(error)")
+                return
+            }
+
+            guard let data = data else {
+                print("No data received from OpenAI")
+                return
+            }
+
+            do {
+                if let jsonResponse = try JSONSerialization.jsonObject(with: data, options: []) as? [String: Any],
+                   let choices = jsonResponse["choices"] as? [[String: Any]],
+                   let message = choices[0]["message"] as? [String : Any],
+                   let content = message["content"] as? String,
+                   let jsonData = content.data(using: .utf8),
+                   let rawCategories = try? JSONDecoder().decode([String].self, from: jsonData).filter({ categories.contains($0) }) {
+                    let suggestedCategories = Category.mapStringsToCategories(returnedStrings: rawCategories)
+                    completion(suggestedCategories)
+                } else {
+                    print("Incorrect response formatting")
+                }
+            } catch {
+                print("Error parsing OpenAI response: \(error)")
+            }
+        }.resume()
+    }
+
+
     func deleteComment(postId: String, commentId: String){
         Firebase.db.collection("POSTS").document(postId).collection("COMMENTS").document(commentId).delete(){ error in
             if let error = error{

Gauge/Feed/ViewModels/UserFirebase.swift

@@ -11,6 +11,36 @@ import FirebaseFirestore
 class UserFirebase: ObservableObject {
     @Published var user: User = User(userId: "exampleUser", username: "exampleUser", email: "[email protected]")
 
+    func getAllUserData(userId: String, completion: @escaping (User) -> Void) {
+        Firebase.db.collection("USERS").document(userId).getDocument { document, error in
+            if let error = error {
+                print("Error getting documents: \(error)")
+            } else {
+                if let data = document?.data() {
+                    let userObj = User(
+                        userId: data["userId"] as? String ?? "",
+                        username: data["username"] as? String ?? "",
+                        phoneNumber: data["phoneNumber"] as? String ?? "",
+                        email: data["email"] as? String ?? "",
+                        friendIn: data["friendIn"] as? [String: [String]] ?? [:],
+                        friendOut: data["friendOut"] as? [String: [String]] ?? [:],
+                        friends: data["friends"] as? [String: [String]] ?? [:],
+                        myPosts: data["myPosts"] as? [String] ?? [],
+                        myResponses: data["myResponses"] as? [String] ?? [],
+                        myFavorites: data["myFavorites"] as? [String] ?? [],
+                        mySearches: data["mySearches"] as? [String] ?? [],
+                        myComments: data["myComments"] as? [String] ?? [],
+                        myCategories: data["myCategories"] as? [String] ?? [],
+                        badges: data["badges"] as? [String] ?? [],
+                        streak: data["streak"] as? Int ?? 0
+                    )
+
+                    completion(userObj)
+                }
+            }
+        }
+    }
+
     func getUserPostInteractions() {
         // create variables to store subcollection info
         var responsePostIDs: [String] = []