placementt-core 11.0.533 → 11.0.803

package/src/reduxHooks.ts

@@ -1,14 +1,16 @@
-import { where } from "firebase/firestore"
+import { orderBy, where } from "firebase/firestore"
 import { useEffect, useState } from "react"
 import { TypedUseSelectorHook, useDispatch, useSelector } from "react-redux"
 import { AppDispatch, RootState } from "./config"
 import { addContact, deleteContact, setContacts, updateContact } from "./features/contacts/contactsSlice"
-import { Job, addJob, setJobStatus, setJobs, setMarkRead } from "./features/jobs/jobsSlice"
-import { fetchActivePlacement } from "./features/placements/studentPlacements/activePlacement"
+import { Job, addJob, setJobStatus, setJobs, setMarkRead, updateJob } from "./features/jobs/jobsSlice"
+import { editActivePlacement, fetchActivePlacement, setActivePlacement } from "./features/placements/studentPlacements/activePlacement"
 import { addCompletedStudentPlacements, deleteCompletedStudentPlacement, setCompletedStudentPlacements, updateCompletedStudentPlacement } from "./features/placements/studentPlacements/completedStudentPlacementsSlice"
 import { addUpcomingStudentPlacements, deleteUpcomingStudentPlacement, setUpcoming, setUpcomingStudentPlacements, updateUpcomingStudentPlacement } from "./features/placements/studentPlacements/upcomingStudentPlacementsSlice"
 import FirebaseQuery from "./firebase/firebaseQuery"
 import { Address, Application, Contact, PlacementListing, ProviderData, StudentPlacementData, UserData } from "./typeDefinitions"
+import {getPlacementsWhere} from "./firebase/readDatabase"
+import {convertDate} from "./firebase/util"
 
 export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector
 export const useAppDispatch = () => useDispatch<AppDispatch>();
@@ -22,7 +24,7 @@ export function useStudent({user} : {user: UserData}) {
     const activePlacement = useAppSelector((state) => state.activePlacement.values)
     const upcoming = useAppSelector((state) => state.upcomingStudentPlacements.upcoming)
     const contacts = useAppSelector((state) => state.contacts.values)
-    const [applications, setApplications] = useState<{[key: string]: Application&{listing: PlacementListing, provider: ProviderData, address: Address}}>();
+    const [applications, setApplications] = useState<{[key: string]: Application&{listing: PlacementListing|false, provider: ProviderData|false, address: Address}}>();
     const firebaseQuery = new FirebaseQuery();
     
     const dispatch = useAppDispatch();
@@ -41,9 +43,9 @@ export function useStudent({user} : {user: UserData}) {
         firebaseQuery.collectionSnapshot(async (fApplications: {[key: string]: Application}) => {
 
             const applicationsWithProviderAndListing:{[key: string]: Application&{listing: PlacementListing, provider: ProviderData, address: Address}} = Object.fromEntries(await Promise.all(Object.entries(fApplications).map(async ([id, application]) => {
-                const provider = await firebaseQuery.getDocData(["providers", application.providerId]) as ProviderData;
-                const listing  = await firebaseQuery.getDocData(["placementListings", application.listingId]) as PlacementListing;
-                const address  = listing.addressId && await firebaseQuery.getDocData(["addresses", listing.addressId]) as Address;
+                const provider = await firebaseQuery.getDocData(["providers", application.providerId]).catch(() => false) as ProviderData|false;
+                const listing = await firebaseQuery.getDocData(["placementListings", application.listingId]).catch(() => false) as PlacementListing|false;
+                const address = listing && listing?.addressId && await firebaseQuery.getDocData(["addresses", listing.addressId]) as Address;
 
                 return [id, {...application, listing: listing, provider: provider, address: address}];
             })));
@@ -51,25 +53,44 @@ export function useStudent({user} : {user: UserData}) {
             setApplications(applicationsWithProviderAndListing);
 
         }, "applications", applicationsConstraints);
-    }, [dispatch, user.id]);
-
+    }, [user.id]);
+/*
     useEffect(() => {
         if (!user.id) return
         dispatch(fetchActivePlacement({userId: user.id}))
-    }, [dispatch, user.id, upcomingPlacements])
+    }, [dispatch, user.id, upcomingPlacements]);
+*/
+    const fetchUpcomingPlacements = () => {
+        const constraints = [where("uid", "==", user.id), where("inProgress", "==", true), orderBy("startDate")]
+        firebaseQuery.collectionSnapshot(setUpcomingStudentPlacements, "placements", constraints, dispatch);
+    }
 
-    useEffect(() => {
-        console.log("UPDATE UPCOMING");
-    
+    const fetchCompletedPlacements = () => {
+        const constraints = [where("uid", "==", user.id), where("completed", "==", true), orderBy("startDate")]
+        firebaseQuery.collectionSnapshot(setCompletedStudentPlacements, "placements", constraints, dispatch);
+    }
+
+    const fetchContacts = () => {
+        const constraints = [where("uid", "==", user.id)]
+        firebaseQuery.collectionSnapshot(setContacts, "contacts", constraints, dispatch);
+    }
+
+    const updateUpcomingPlacement = () => {
         if (!upcomingPlacements || !Object.entries(upcomingPlacements).length) {
             dispatch(setUpcoming(undefined));
             return;
         }
         const upcomingPlacement = Object.entries(upcomingPlacements).find(([, v]) => new Date(v.startDate).getTime() > today.getTime())
         upcomingPlacement ? dispatch(setUpcoming(upcomingPlacement[1])) : dispatch(setUpcoming(undefined))
+    }
 
-    }, [dispatch, upcomingPlacements]);
-    
+    const updateActivePlacement = () => {
+        const key = Object.keys(upcomingPlacements).find((key) => {
+            const placement = upcomingPlacements[key]
+            return placement.active
+        })
+        key ? dispatch(setActivePlacement(upcomingPlacements[key])) : dispatch(setActivePlacement(null))
+    }
 
     const getItemById = async (path: "contacts"|"placements", id: string) => {
         return await firebaseQuery.getDocData([path, id]) 
@@ -80,9 +101,9 @@ export function useStudent({user} : {user: UserData}) {
         else dispatch(deleteCompletedStudentPlacement({placementId: id}))
     }
 
-    const handleUpdatePlacement = async (id: string, data: StudentPlacementData)  => {
-        if (upcomingPlacements[id]) dispatch(updateUpcomingStudentPlacement({placementId: id, attributes: data}))
-        else dispatch(updateCompletedStudentPlacement({placementId: id, attributes: data}))
+    const handleUpdatePlacement = async (id: string, attributes: Partial<StudentPlacementData>)  => {
+        if (upcomingPlacements[id]) dispatch(updateUpcomingStudentPlacement({placementId: id, attributes}))
+        else dispatch(updateCompletedStudentPlacement({placementId: id, attributes}))
     }
 
     const handleAddPlacement = async (formData: StudentPlacementData) => {
@@ -90,19 +111,46 @@ export function useStudent({user} : {user: UserData}) {
        else dispatch(addUpcomingStudentPlacements({formData}))
     }
 
+    const getUserPlacements = async () => {
+        return await getPlacementsWhere({w: where("uid", "==", user?.id)})
+    }
+
+    const getPlacementsStart = async (start: Date, end: Date) => {
+        return await firebaseQuery.getDocsWhere("placements", [where("uid", "==", user?.id), where("startDate", ">=", convertDate(start, "dbstring")), where("startDate", "<=", convertDate(end, "dbstring"))]) as {[key:string]: StudentPlacementData};
+    }
+
+    const getPlacementsEnd = async (end: Date) => {
+        return await firebaseQuery.getDocsWhere("placements", [where("uid", "==", user?.id), where("endDate", ">=", convertDate(end, "dbstring")), where("endDate", "<=", convertDate(end, "dbstring"))]) as {[key:string]: StudentPlacementData};
+    }
+
+    const dispatchActivePlacement = () => {
+        dispatch(fetchActivePlacement({userId: user.id}))
+    }
+
     return {
         contacts: {
-            add: async (contactForm: Contact) => dispatch(addContact({contactForm: contactForm, userId: user.id})),
-            update: async (contactId: string, data: Partial<Contact>) => dispatch(updateContact({contactId: contactId, attributes: data})),
-            delete: async (contactId: string) => dispatch(deleteContact({contactId: contactId})),
+            add: async (contactForm: Contact) => await dispatch(addContact({contactForm: contactForm, userId: user.id})),
+            update: async (contactId: string, data: Partial<Contact>) => await dispatch(updateContact({contactId: contactId, attributes: data})),
+            delete: async (contactId: string) => await dispatch(deleteContact({contactId: contactId})),
             contacts,
+            fetchContacts,
             getById: async (item: string) => await getItemById("contacts", item)
         },
+
         placements: {
             add: async (formData: StudentPlacementData) => await handleAddPlacement(formData),
-            update: async (placementId: string, data: StudentPlacementData) => handleUpdatePlacement(placementId, data),
+            update: async (placementId: string, attributes: Partial<StudentPlacementData>) => await handleUpdatePlacement(placementId, attributes),
             delete: async (id: string) => await handleDeletePlacement(id),
+            getUserPlacements,
+            getPlacementsStart,
+            getPlacementsEnd,
             activePlacement,
+            editActivePlacement: (attributes: Partial<StudentPlacementData>) => dispatch(editActivePlacement(attributes)),
+            updateActivePlacement,
+            updateUpcomingPlacement,
+            fetchUpcomingPlacements,
+            fetchCompletedPlacements,
+            dispatchActivePlacement,
             upcoming,
             upcomingPlacements: upcomingPlacements || {}, 
             completedPlacements: completedPlacements || {},
@@ -135,6 +183,7 @@ export function useInstituteStaff({user}: {user: UserData}) {
             addJob: async ({job, jobId} : {job: Partial<Job>, jobId: string}) => dispatch(addJob({job: job, jobId: jobId})),
             setMarkRead: async (payload) =>  dispatch(setMarkRead(payload)),
             setJobStatus: async ({jobId, status}: {jobId: string, status: string}) => dispatch(setJobStatus({jobId: jobId, status: status})),
+            updateJob: async ({jobId, data}: {jobId: string, data: string}) => dispatch(updateJob({jobId: jobId, data: data})),
             getById: getJobById
         }
     }