Merge branch 'dev'

# Conflicts:
#	app/(auth)/_layout.tsx
#	components/pages/settings/user_settings_views/MyProfile.tsx
#	yarn.lock

hooks/firebase/useCreateFeedback.ts

@@ -0,0 +1,85 @@
+import {useAuthContext} from "@/contexts/AuthContext";
+import {useMutation, useQueryClient} from "react-query";
+import firestore from "@react-native-firebase/firestore";
+import { IFeedback } from "@/contexts/FeedbackContext";
+
+export const useCreateFeedback = () => {
+    const {user: currentUser, profileData} = useAuthContext()
+    const queryClients = useQueryClient()
+
+    return useMutation({
+        mutationKey: ["createFeedback"],
+        mutationFn: async (feedback: Partial<IFeedback>) => {
+            try {
+                if (feedback.id) {
+                    const snapshot = await firestore()
+                        .collection("Feedbacks")
+                        .where("id", "==", feedback.id)
+                        .get();
+
+                    if (!snapshot.empty) {
+                        const docId = snapshot.docs[0].id;
+                        await firestore()
+                            .collection("Feedbacks")
+                            .doc(docId)
+                            .set({
+                                ...feedback,
+                                creatorId: currentUser?.uid,
+                            }, {merge: true});
+                        return;
+                    }
+                }
+                const newDoc = firestore().collection('Feedbacks').doc();
+                await firestore()
+                    .collection("Feedbacks")
+                    .add({...feedback, id: newDoc.id, creatorId: currentUser?.uid});
+            } catch (e) {
+                console.error(e);
+            }
+        },
+        onSuccess: () => {
+            queryClients.invalidateQueries("feedbacks")
+        }
+    })
+}
+
+export const useCreateFeedbacksFromProvider = () => {
+    const { user: currentUser } = useAuthContext();
+    const queryClient = useQueryClient();
+
+    return useMutation({
+        mutationKey: ["createFeedbacksFromProvider"],
+        mutationFn: async (feedbackDataArray: Partial<IFeedback>[]) => {
+            try {
+                const promises = feedbackDataArray.map(async (feedbackData) => {
+                    console.log("Processing FeedbackData: ", feedbackData);
+
+                    const snapshot = await firestore()
+                        .collection("Feedbacks")
+                        .where("id", "==", feedbackData.id)
+                        .get();
+
+                    if (snapshot.empty) {
+                        return firestore()
+                            .collection("Feedbacks")
+                            .add({ ...feedbackData, creatorId: currentUser?.uid });
+                    } else {
+                        const docId = snapshot.docs[0].id;
+                        return firestore()
+                            .collection("Feedbacks")
+                            .doc(docId)
+                            .set({ ...feedbackData, creatorId: currentUser?.uid }, { merge: true });
+                    }
+                });
+
+                await Promise.all(promises);
+
+            } catch (e) {
+                console.error("Error creating/updating feedbacks: ", e);
+            }
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries("feedbacks");
+        }
+    });
+};

hooks/firebase/useCreateNote.ts

@@ -0,0 +1,91 @@
+import { useAuthContext } from "@/contexts/AuthContext";
+import { useMutation, useQueryClient } from "react-query";
+import firestore from "@react-native-firebase/firestore";
+import { IFeedback } from "@/contexts/FeedbackContext";
+import { IBrainDump } from "@/contexts/DumpContext";
+
+export const useCreateNote = () => {
+  const { user: currentUser, profileData } = useAuthContext();
+  const queryClients = useQueryClient();
+
+  return useMutation({
+    mutationKey: ["createNote"],
+    mutationFn: async (note: Partial<IBrainDump>) => {
+      try {
+        if (note.id) {
+          const snapshot = await firestore()
+            .collection("BrainDumps")
+            .where("id", "==", note.id)
+            .get();
+
+          if (!snapshot.empty) {
+            const docId = snapshot.docs[0].id;
+            await firestore()
+              .collection("BrainDumps")
+              .doc(docId)
+              .set(
+                {
+                  ...note,
+                  creatorId: currentUser?.uid,
+                },
+                { merge: true }
+              );
+            return;
+          }
+        }
+        const newDoc = firestore().collection("BrainDumps").doc();
+        await firestore()
+          .collection("BrainDumps")
+          .add({ ...note, id: newDoc.id, creatorId: currentUser?.uid });
+      } catch (e) {
+        console.error(e);
+      }
+    },
+    onSuccess: () => {
+      queryClients.invalidateQueries("braindumps");
+    },
+  });
+};
+
+export const useCreateNotesFromProvider = () => {
+  const { user: currentUser } = useAuthContext();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationKey: ["createNotesFromProvider"],
+    mutationFn: async (noteDataArray: Partial<IFeedback>[]) => {
+      try {
+        const promises = noteDataArray.map(async (noteData) => {
+          console.log("Processing NoteData: ", noteData);
+
+          const snapshot = await firestore()
+            .collection("BrainDumps")
+            .where("id", "==", noteData.id)
+            .get();
+
+          if (snapshot.empty) {
+            return firestore()
+              .collection("BrainDumps")
+              .add({ ...noteData, creatorId: currentUser?.uid });
+          } else {
+            const docId = snapshot.docs[0].id;
+            return firestore()
+              .collection("BrainDumps")
+              .doc(docId)
+              .set(
+                { ...noteData, creatorId: currentUser?.uid },
+                { merge: true }
+              );
+          }
+        });
+
+        await Promise.all(promises);
+      } catch (e) {
+        console.error("Error creating/updating braindumps: ", e);
+      }
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries("braindumps");
+    },
+  });
+};

hooks/firebase/useDeleteFeedback.ts

@@ -0,0 +1,45 @@
+import {useAuthContext} from "@/contexts/AuthContext";
+import {useMutation, useQueryClient} from "react-query";
+import firestore from "@react-native-firebase/firestore";
+
+export const useDeleteFeedback = () => {
+  const { user: currentUser } = useAuthContext();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationKey: ["deleteFeedback"],
+    mutationFn: async (feedbackId: string) => {
+      try {
+        // Find the document with matching id field
+        const snapshot = await firestore()
+          .collection("Feedbacks")
+          .where("id", "==", feedbackId)
+          .get();
+
+        if (snapshot.empty) {
+          throw new Error("Feedback not found");
+        }
+
+        // Get the first matching document
+        const docId = snapshot.docs[0].id;
+
+        // Optional: Check if the current user is the creator
+        const feedbackData = snapshot.docs[0].data();
+        if (feedbackData.creatorId !== currentUser?.uid) {
+          throw new Error(
+            "Unauthorized: You can only delete your own feedback"
+          );
+        }
+
+        // Delete the document
+        await firestore().collection("Feedbacks").doc(docId).delete();
+      } catch (e) {
+        console.error("Error deleting feedback: ", e);
+        throw e; // Re-throw the error to be handled by the mutation
+      }
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries("feedbacks");
+    },
+  });
+};

hooks/firebase/useDeleteNote.ts

@@ -0,0 +1,39 @@
+import { useAuthContext } from "@/contexts/AuthContext";
+import { useMutation, useQueryClient } from "react-query";
+import firestore from "@react-native-firebase/firestore";
+
+export const useDeleteNote = () => {
+  const { user: currentUser } = useAuthContext();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationKey: ["deleteNote"],
+    mutationFn: async (noteId: string) => {
+      try {
+        const snapshot = await firestore()
+          .collection("BrainDumps")
+          .where("id", "==", noteId)
+          .get();
+
+        if (snapshot.empty) {
+          throw new Error("Note not found");
+        }
+
+        const docId = snapshot.docs[0].id;
+
+        const noteData = snapshot.docs[0].data();
+        if (noteData.creatorId !== currentUser?.uid) {
+          throw new Error("Unauthorized: You can only delete your own Note");
+        }
+
+        await firestore().collection("BrainDumps").doc(docId).delete();
+      } catch (e) {
+        console.error("Error deleting note: ", e);
+        throw e;
+      }
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries("braindumps");
+    },
+  });
+};

hooks/firebase/useGetFeedbacks.ts

@@ -0,0 +1,28 @@
+import { useAuthContext } from "@/contexts/AuthContext";
+import { useQuery } from "react-query";
+import firestore from "@react-native-firebase/firestore";
+import { IFeedback } from "@/contexts/FeedbackContext";
+
+export const useGetFeedbacks = () => {
+  const { user: currentUser } = useAuthContext();
+
+  return useQuery<IFeedback[]>({
+    queryKey: ["feedbacks", currentUser?.uid],
+    queryFn: async () => {
+      try {
+        const snapshot = await firestore()
+          .collection("Feedbacks")
+          .where("creatorId", "==", currentUser?.uid)
+          .get();
+
+        return snapshot.docs.map((doc) => ({
+          ...doc.data(),
+        })) as IFeedback[];
+      } catch (error) {
+        console.error("Error fetching feedbacks:", error);
+        throw error;
+      }
+    },
+    enabled: !!currentUser?.uid, // Only run query if we have a user ID
+  });
+};

hooks/firebase/useGetNotes.ts

@@ -0,0 +1,28 @@
+import { useAuthContext } from "@/contexts/AuthContext";
+import { useQuery } from "react-query";
+import firestore from "@react-native-firebase/firestore";
+import { IBrainDump } from "@/contexts/DumpContext";
+
+export const useGetNotes = () => {
+  const { user: currentUser } = useAuthContext();
+
+  return useQuery<IBrainDump[]>({
+    queryKey: ["braindumps", currentUser?.uid],
+    queryFn: async () => {
+      try {
+        const snapshot = await firestore()
+          .collection("BrainDumps")
+          .where("creatorId", "==", currentUser?.uid)
+          .get();
+
+        return snapshot.docs.map((doc) => ({
+          ...doc.data(),
+        })) as IBrainDump[];
+      } catch (error) {
+        console.error("Error fetching braindumps:", error);
+        throw error;
+      }
+    },
+    enabled: !!currentUser?.uid,
+  });
+};

hooks/firebase/useUpdateFeedback.ts

@@ -0,0 +1,65 @@
+import { useAuthContext } from "@/contexts/AuthContext";
+import { useMutation, useQueryClient } from "react-query";
+import firestore from "@react-native-firebase/firestore";
+import { IFeedback } from "@/contexts/FeedbackContext";
+
+interface UpdateFeedbackParams {
+  id: number;
+  changes: Partial<IFeedback>;
+}
+
+export const useUpdateFeedback = () => {
+  const { user: currentUser } = useAuthContext();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationKey: ["updateFeedback"],
+    mutationFn: async ({ id, changes }: UpdateFeedbackParams) => {
+      try {
+        const snapshot = await firestore()
+          .collection("Feedbacks")
+          .where("id", "==", id)
+          .get();
+
+        if (snapshot.empty) {
+          throw new Error("Feedback not found");
+        }
+
+        const docId = snapshot.docs[0].id;
+        const feedbackData = snapshot.docs[0].data();
+
+        if (feedbackData.creatorId !== currentUser?.uid) {
+          throw new Error(
+            "Unauthorized: You can only update your own feedback"
+          );
+        }
+
+        await firestore()
+          .collection("Feedbacks")
+          .doc(docId)
+          .update({
+            ...changes,
+            updatedAt: firestore.FieldValue.serverTimestamp(),
+            lastModifiedBy: currentUser?.uid,
+          });
+
+        return {
+          id,
+          ...feedbackData,
+          ...changes,
+        };
+      } catch (e) {
+        console.error("Error updating feedback: ", e);
+        throw e;
+      }
+    },
+    onSuccess: (updatedFeedback) => {
+      queryClient.invalidateQueries("feedbacks");
+
+      queryClient.setQueryData(
+        ["feedback", updatedFeedback.id],
+        updatedFeedback
+      );
+    },
+  });
+};

hooks/firebase/useUpdateNote.ts

@@ -0,0 +1,65 @@
+import { useAuthContext } from "@/contexts/AuthContext";
+import { useMutation, useQueryClient } from "react-query";
+import firestore from "@react-native-firebase/firestore";
+import { IBrainDump } from "@/contexts/DumpContext";
+
+interface UpdateNoteParams {
+  id: number;
+  changes: Partial<IBrainDump>;
+}
+
+export const useUpdateNote = () => {
+  const { user: currentUser } = useAuthContext();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationKey: ["updateNote"],
+    mutationFn: async ({ id, changes }: UpdateNoteParams) => {
+      try {
+        const snapshot = await firestore()
+          .collection("BrainDumps")
+          .where("id", "==", id)
+          .get();
+
+        if (snapshot.empty) {
+          throw new Error("Note not found");
+        }
+
+        const docId = snapshot.docs[0].id;
+        const noteData = snapshot.docs[0].data();
+
+        if (noteData.creatorId !== currentUser?.uid) {
+          throw new Error(
+            "Unauthorized: You can only update your own note"
+          );
+        }
+
+        await firestore()
+          .collection("BrainDumps")
+          .doc(docId)
+          .update({
+            ...changes,
+            updatedAt: firestore.FieldValue.serverTimestamp(),
+            lastModifiedBy: currentUser?.uid,
+          });
+
+        return {
+          id,
+          ...noteData,
+          ...changes,
+        };
+      } catch (e) {
+        console.error("Error updating note: ", e);
+        throw e;
+      }
+    },
+    onSuccess: (updatedNote) => {
+      queryClient.invalidateQueries("braindumps");
+
+      queryClient.setQueryData(
+        ["feedback", updatedNote.id],
+        updatedNote
+      );
+    },
+  });
+};