Merge remote-tracking branch 'origin/main' into dev

hooks/firebase/types/profileTypes.ts

@@ -1,10 +1,29 @@
-import {ProfileType} from "@/contexts/AuthContext";
+export type ProfileType = 'parent' | 'child';
 
-export interface User {
-    uid: string;
-    email: string | null;
+export interface CalendarAccount {
+    accessToken: string;
+    refreshToken?: string;
+    resourceId?: string;
+    email?: string;
+    expiresAt?: Date;
 }
 
+export interface GoogleAccount extends CalendarAccount {
+    scope?: string;
+}
+
+export interface MicrosoftAccount extends CalendarAccount {
+    subscriptionId?: string;
+}
+
+export interface AppleAccount extends CalendarAccount {
+    identityToken?: string;
+}
+
+export type CalendarAccounts = {
+    [email: string]: GoogleAccount | MicrosoftAccount | AppleAccount;
+};
+
 export interface UserProfile {
     userType: ProfileType;
     firstName: string;
@@ -21,23 +40,7 @@ export interface UserProfile {
     eventColor?: string | null;
     timeZone?: string | null;
     firstDayOfWeek?: string | null;
-    googleAccounts?: Object;
-    microsoftAccounts?: Object;
-    appleAccounts?: Object;
-}
-
-export interface ParentProfile extends UserProfile {
-    userType: ProfileType.PARENT;
-    childrenIds: string[];
-}
-
-export interface ChildProfile extends UserProfile {
-    userType: ProfileType.CHILD;
-    birthday: Date;
-    parentId: string;
-}
-
-export interface CaregiverProfile extends UserProfile {
-    userType: ProfileType.CAREGIVER;
-    contact: string;
-}
+    googleAccounts?: { [email: string]: GoogleAccount };
+    microsoftAccounts?: { [email: string]: MicrosoftAccount };
+    appleAccounts?: { [email: string]: AppleAccount };
+}

hooks/firebase/useCreateEvent.ts

@@ -24,6 +24,7 @@ export const useCreateEvent = () => {
                             .doc(docId)
                             .set({
                                 ...eventData,
+                                attendees: (eventData.attendees?.length ?? 0) === 0 ?? [currentUser?.uid],
                                 creatorId: currentUser?.uid,
                                 familyId: profileData?.familyId
                             }, {merge: true});
@@ -37,15 +38,12 @@ export const useCreateEvent = () => {
             } catch (e) {
                 console.error(e);
             }
-        },
-        onSuccess: () => {
-            queryClients.invalidateQueries("events")
         }
     })
 }
 
 export const useCreateEventsFromProvider = () => {
-    const { user: currentUser } = useAuthContext();
+    const {user: currentUser} = useAuthContext();
     const queryClient = useQueryClient();
 
     return useMutation({
@@ -66,14 +64,14 @@ export const useCreateEventsFromProvider = () => {
                         // Event doesn't exist, so add it
                         return firestore()
                             .collection("Events")
-                            .add({ ...eventData, creatorId: currentUser?.uid });
+                            .add({...eventData, creatorId: currentUser?.uid});
                     } else {
                         // Event exists, update it
                         const docId = snapshot.docs[0].id;
                         return firestore()
                             .collection("Events")
                             .doc(docId)
-                            .set({ ...eventData, creatorId: currentUser?.uid }, { merge: true });
+                            .set({...eventData, creatorId: currentUser?.uid}, {merge: true});
                     }
                 });
 

hooks/firebase/useDeleteNotification.ts

@@ -0,0 +1,37 @@
+import {useMutation, useQueryClient} from "react-query";
+import {useAuthContext} from "@/contexts/AuthContext";
+import firestore from "@react-native-firebase/firestore";
+import {Notification} from "@/hooks/firebase/useGetNotifications";
+
+export const useDeleteNotification = () => {
+    const queryClient = useQueryClient();
+    const {user} = useAuthContext();
+
+    return useMutation({
+        mutationFn: async (id: string) => {
+            await firestore()
+                .collection("Notifications")
+                .doc(id)
+                .delete();
+        },
+        onMutate: async (deletedId) => {
+            await queryClient.cancelQueries(["notifications", user?.uid]);
+
+            const previousNotifications = queryClient.getQueryData<Notification[]>(["notifications", user?.uid]);
+
+            queryClient.setQueryData<Notification[]>(["notifications", user?.uid], (old) =>
+                old?.filter((notification) => notification?.id! !== deletedId) ?? []
+            );
+
+            return {previousNotifications};
+        },
+        onError: (_err, _deletedId, context) => {
+            if (context?.previousNotifications) {
+                queryClient.setQueryData(["notifications", user?.uid], context.previousNotifications);
+            }
+        },
+        onSettled: () => {
+            queryClient.invalidateQueries(["notifications", user?.uid]);
+        },
+    });
+};

hooks/firebase/useGetEvents.ts

@@ -1,80 +1,202 @@
-import { useQuery } from "react-query";
+import {useQuery, useQueryClient} from "react-query";
 import firestore from "@react-native-firebase/firestore";
-import { useAuthContext } from "@/contexts/AuthContext";
-import { useAtomValue } from "jotai";
-import { isFamilyViewAtom } from "@/components/pages/calendar/atoms";
-import { colorMap } from "@/constants/colorMap";
+import {useAuthContext} from "@/contexts/AuthContext";
+import {useAtomValue} from "jotai";
+import {isFamilyViewAtom} from "@/components/pages/calendar/atoms";
+import {colorMap} from "@/constants/colorMap";
 import {uuidv4} from "@firebase/util";
+import {useEffect} from "react";
+
+const createEventHash = (event: any): string => {
+    const str = `${event.startDate?.seconds || ''}-${event.endDate?.seconds || ''}-${
+        event.title || ''
+    }-${event.location || ''}-${event.allDay ? 'true' : 'false'}`;
+
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash;
+    }
+    return hash.toString(36);
+};
+
 
 export const useGetEvents = () => {
-    const { user, profileData } = useAuthContext();
+    const {user, profileData} = useAuthContext();
     const isFamilyView = useAtomValue(isFamilyViewAtom);
+    const queryClient = useQueryClient();
+
+    useEffect(() => {
+        if (!profileData?.familyId) {
+            console.log('[SYNC] No family ID available, skipping listener setup');
+            return;
+        }
+
+        console.log('[SYNC] Setting up sync listener', {
+            familyId: profileData.familyId,
+            userId: user?.uid,
+            isFamilyView
+        });
+
+        const unsubscribe = firestore()
+            .collection('Households')
+            .where("familyId", "==", profileData.familyId)
+            .onSnapshot((snapshot) => {
+                console.log('[SYNC] Snapshot received', {
+                    empty: snapshot.empty,
+                    size: snapshot.size,
+                    changes: snapshot.docChanges().length
+                });
+
+                snapshot.docChanges().forEach((change) => {
+                    console.log('[SYNC] Processing change', {
+                        type: change.type,
+                        docId: change.doc.id,
+                        newData: change.doc.data()
+                    });
+
+                    if (change.type === 'modified') {
+                        const data = change.doc.data();
+                        console.log('[SYNC] Modified document data', {
+                            hasLastSyncTimestamp: !!data?.lastSyncTimestamp,
+                            hasLastUpdateTimestamp: !!data?.lastUpdateTimestamp,
+                            allFields: Object.keys(data || {})
+                        });
+
+                        if (data?.lastSyncTimestamp) {
+                            console.log('[SYNC] Sync timestamp change detected', {
+                                timestamp: data.lastSyncTimestamp.toDate(),
+                                householdId: change.doc.id,
+                                queryKey: ["events", user?.uid, isFamilyView]
+                            });
+
+                            console.log('[SYNC] Invalidating queries...');
+                            queryClient.invalidateQueries(["events", user?.uid, isFamilyView]);
+                            console.log('[SYNC] Queries invalidated');
+                        } else {
+                            console.log('[SYNC] Modified document without lastSyncTimestamp', {
+                                householdId: change.doc.id
+                            });
+                        }
+                    }
+                });
+            }, (error) => {
+                console.error('[SYNC] Listener error:', {
+                    message: error.message,
+                    code: error.code,
+                    stack: error.stack
+                });
+            });
+
+        console.log('[SYNC] Listener setup complete');
+
+        return () => {
+            console.log('[SYNC] Cleaning up sync listener', {
+                familyId: profileData.familyId,
+                userId: user?.uid
+            });
+            unsubscribe();
+        };
+    }, [profileData?.familyId, user?.uid, isFamilyView, queryClient]);
+
 
     return useQuery({
         queryKey: ["events", user?.uid, isFamilyView],
         queryFn: async () => {
+            console.log(`Fetching events - Family View: ${isFamilyView}, User: ${user?.uid}`);
+
             const db = firestore();
             const userId = user?.uid;
             const familyId = profileData?.familyId;
-
             let allEvents = [];
 
-            // If family view is active, include family, creator, and attendee events
             if (isFamilyView) {
-                const familyQuery = db.collection("Events").where("familyId", "==", familyId);
-                const attendeeQuery = db.collection("Events").where("attendees", "array-contains", userId);
+                const [publicFamilyEvents, privateCreatorEvents, privateAttendeeEvents, userAttendeeEvents, userCreatorEvents] = await Promise.all([
+                    // Public family events
+                    db.collection("Events")
+                        .where("familyId", "==", familyId)
+                        .where("private", "==", false)
+                        .get(),
 
-                const [familySnapshot, attendeeSnapshot] = await Promise.all([
-                    familyQuery.get(),
-                    attendeeQuery.get(),
+                    // Private events user created
+                    db.collection("Events")
+                        .where("familyId", "==", familyId)
+                        .where("private", "==", true)
+                        .where("creatorId", "==", userId)
+                        .get(),
+
+                    // Private events user is attending
+                    db.collection("Events")
+                        .where("private", "==", true)
+                        .where("attendees", "array-contains", userId)
+                        .get(),
+
+                    // All events where user is attendee
+                    db.collection("Events")
+                        .where("attendees", "array-contains", userId)
+                        .get(),
+
+                    // ALL events where user is creator (regardless of attendees)
+                    db.collection("Events")
+                        .where("creatorId", "==", userId)
+                        .get()
                 ]);
 
-                // Collect all events
-                const familyEvents = familySnapshot.docs.map(doc => doc.data());
-                const attendeeEvents = attendeeSnapshot.docs.map(doc => doc.data());
+                console.log(`Found ${publicFamilyEvents.size} public events, ${privateCreatorEvents.size} private creator events, ${privateAttendeeEvents.size} private attendee events, ${userAttendeeEvents.size} user attendee events, ${userCreatorEvents.size} user creator events`);
 
-                // console.log("Family events not in creator query: ", familyEvents.filter(event => !creatorEvents.some(creatorEvent => creatorEvent.id === event.id)));
-
-
-                allEvents = [...familyEvents, ...attendeeEvents];
+                allEvents = [
+                    ...publicFamilyEvents.docs.map(doc => ({...doc.data(), id: doc.id})),
+                    ...privateCreatorEvents.docs.map(doc => ({...doc.data(), id: doc.id})),
+                    ...privateAttendeeEvents.docs.map(doc => ({...doc.data(), id: doc.id})),
+                    ...userAttendeeEvents.docs.map(doc => ({...doc.data(), id: doc.id})),
+                    ...userCreatorEvents.docs.map(doc => ({...doc.data(), id: doc.id}))
+                ];
             } else {
-                // Only include creator and attendee events when family view is off
-                const creatorQuery = db.collection("Events").where("creatorId", "==", userId);
-                const attendeeQuery = db.collection("Events").where("attendees", "array-contains", userId);
-
-                const [creatorSnapshot, attendeeSnapshot] = await Promise.all([
-                    creatorQuery.get(),
-                    attendeeQuery.get(),
+                const [creatorEvents, attendeeEvents] = await Promise.all([
+                    db.collection("Events")
+                        .where("creatorId", "==", userId)
+                        .get(),
+                    db.collection("Events")
+                        .where("attendees", "array-contains", userId)
+                        .get()
                 ]);
 
-                const creatorEvents = creatorSnapshot.docs.map(doc => doc.data());
-                const attendeeEvents = attendeeSnapshot.docs.map(doc => doc.data());
+                console.log(`Found ${creatorEvents.size} creator events, ${attendeeEvents.size} attendee events`);
 
-                allEvents = [...creatorEvents, ...attendeeEvents];
+                allEvents = [
+                    ...creatorEvents.docs.map(doc => ({...doc.data(), id: doc.id})),
+                    ...attendeeEvents.docs.map(doc => ({...doc.data(), id: doc.id}))
+                ];
             }
 
-            // Use a Map to ensure uniqueness only for events with IDs
             const uniqueEventsMap = new Map();
+            const processedHashes = new Set();
+
             allEvents.forEach(event => {
-                if (event.id) {
-                    uniqueEventsMap.set(event.id, event); // Ensure uniqueness for events with IDs
+                    const eventHash = createEventHash(event);
+
+            console.log(`Processing ${uniqueEventsMap.size} unique events`);
+
+                const processedEvent = {
+                    ...event,
+                    id: event.id || uuidv4(),
+                    creatorId: event.creatorId || userId
+                };
+
+                // Only add the event if we haven't seen this hash before
+                if (!processedHashes.has(eventHash)) {
+                    processedHashes.add(eventHash);
+                    uniqueEventsMap.set(processedEvent.id, processedEvent);
                 } else {
-                    uniqueEventsMap.set(uuidv4(), event); // Generate a temp key for events without ID
+                    console.log(`Duplicate event detected and skipped using hash: ${eventHash}`);
                 }
             });
-            const uniqueEvents = Array.from(uniqueEventsMap.values());
 
-            // Filter out private events unless the user is the creator
-            const filteredEvents = uniqueEvents.filter(event => {
-                if (event.private) {
-                    return event.creatorId === userId;
-                }
-                return true;
-            });
+            console.log(`Processing ${uniqueEventsMap.size} unique events after deduplication`);
 
-            // Attach event colors and return the final list of events
-            return await Promise.all(
-                filteredEvents.map(async (event) => {
+            const processedEvents = await Promise.all(
+                Array.from(uniqueEventsMap.values()).map(async (event) => {
                     const profileSnapshot = await db
                         .collection("Profiles")
                         .doc(event.creatorId)
@@ -85,19 +207,28 @@ export const useGetEvents = () => {
 
                     return {
                         ...event,
-                        id: event.id || Math.random().toString(36).slice(2, 9), // Generate temp ID if missing
-                        title: event.title,
-                        start: new Date(event.startDate.seconds * 1000),
-                        end: new Date(event.endDate.seconds * 1000),
+                        start: event.allDay
+                            ? new Date(new Date(event.startDate.seconds * 1000).setHours(0, 0, 0, 0))
+                            : new Date(event.startDate.seconds * 1000),
+                        end: event.allDay
+                            ? new Date(new Date(event.endDate.seconds * 1000).setHours(0, 0, 0, 0))
+                            : new Date(event.endDate.seconds * 1000),
                         hideHours: event.allDay,
                         eventColor,
                         notes: event.notes,
                     };
                 })
             );
+
+
+            console.log(`Events processing completed, returning ${processedEvents.length} events`);
+            return processedEvents;
         },
-        staleTime: Infinity,
-        cacheTime: Infinity,
+        staleTime: 5 * 60 * 1000,
+        cacheTime: 30 * 60 * 1000,
         keepPreviousData: true,
+        onError: (error) => {
+            console.error('Error fetching events:', error);
+        }
     });
-};
+};

hooks/firebase/useGetNotifications.ts

@@ -1,11 +1,35 @@
-import {useQuery} from "react-query";
+import { useQuery } from "react-query";
 import firestore from "@react-native-firebase/firestore";
-import {useAuthContext} from "@/contexts/AuthContext";
+import { useAuthContext } from "@/contexts/AuthContext";
+
+interface FirestoreTimestamp {
+    seconds: number;
+    nanoseconds: number;
+}
+
+interface NotificationFirestore {
+    creatorId: string;
+    familyId: string;
+    content: string;
+    eventId: string;
+    timestamp: FirestoreTimestamp;
+    date?: FirestoreTimestamp;
+}
+
+export interface Notification {
+    id: string;
+    creatorId: string;
+    familyId: string;
+    content: string;
+    eventId: string;
+    timestamp: Date;
+    date?: Date;
+}
 
 export const useGetNotifications = () => {
     const { user, profileData } = useAuthContext();
 
-    return useQuery({
+    return useQuery<Notification[], Error>({
         queryKey: ["notifications", user?.uid],
         queryFn: async () => {
             const snapshot = await firestore()
@@ -14,16 +38,17 @@ export const useGetNotifications = () => {
                 .get();
 
             return snapshot.docs.map((doc) => {
-                const data = doc.data();
+                const data = doc.data() as NotificationFirestore;
 
-                return {...data, timestamp: new Date(data.timestamp.seconds * 1000 + data.timestamp.nanoseconds / 1e6)} as {
-                    creatorId: string,
-                    familyId: string,
-                    content: string,
-                    eventId: string,
-                    timestamp: Date,
+                return {
+                    id: doc.id,
+                    ...data,
+                    timestamp: new Date(data.timestamp.seconds * 1000 + data.timestamp.nanoseconds / 1e6),
+                    date: data.date ? new Date(data.date.seconds * 1000 + data.date.nanoseconds / 1e6) : undefined
                 };
             });
-        }
-    })
+        },
+        refetchOnWindowFocus: true,
+        staleTime: 60000,
+    });
 };

hooks/firebase/useSignOut.ts

@@ -1,11 +1,14 @@
 import {useMutation} from "react-query";
 import auth from "@react-native-firebase/auth";
+import {useRouter} from "expo-router";
 
 export const useSignOut = () => {
+    const {replace} = useRouter();
     return useMutation({
         mutationKey: ["signOut"],
         mutationFn: async () => {
             await auth().signOut()
+            replace("/(unauth)")
         }
     });
 }