placementt-core 11.0.533 → 11.0.892

package/src/reduxHooks.ts

@@ -1,28 +1,30 @@
-import { where } from "firebase/firestore"
+import { documentId, 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 { Address, Application, CohortData, Contact, EmailTemplate, InstituteData, PlacementListing, ProviderData, StudentPlacementData, UserData, UserGroupData } from "./typeDefinitions"
+import {getOrganisation, getPlacementsWhere} from "./firebase/readDatabase"
+import {convertDate} from "./firebase/util"
 
 export const useAppSelector: TypedUseSelectorHook<RootState> = useSelector
 export const useAppDispatch = () => useDispatch<AppDispatch>();
 
 
 export function useStudent({user} : {user: UserData}) {
-    if (!user || user.product !== "students") return {};
+    if (!user || user.userType !== "Students") return {error: "Unauthorized"};
     
     const upcomingPlacements = useAppSelector((state) => state.upcomingStudentPlacements.values)
     const completedPlacements = useAppSelector((state) => state.completedStudentPlacements.values)
     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,35 +43,52 @@ 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;
-
-                return [id, {...application, listing: listing, provider: provider, address: 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;
+                return [id, {...application, listing: listing, provider: provider}];
             })));
 
             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 +99,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 +109,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 || {},
@@ -114,10 +160,28 @@ export function useStudent({user} : {user: UserData}) {
 
 
 export function useInstituteStaff({user}: {user: UserData}) {
+    if (!user || user?.product !== "institutes" || user.userType !== "Staff") return {error: "Unauthorized"};
+    
     const firebaseQuery = new FirebaseQuery();
     const dispatch = useAppDispatch();
+    const {userGroups, forms, institute} = useInstitute({user})
+    const [cohorts, setCohorts] = useState<{[key:string]: CohortData}>(); 
+    const [emailTemplates, setEmailTemplates] = useState<{[key:string]: EmailTemplate}>();
+
 
-    if (!user || user?.product !== "institutes" || user.userType !== "Staff") return {};
+    useEffect(() => {
+        const cohortConstraints = [where("oId", "==", user.oId)];
+        if (user.userGroup !== "admin") {
+            if (user.viewAddresses !== "all") {
+                cohortConstraints.push(where("addressId", "in", user.visibleAddresses));
+            }
+            if (user.viewCohorts !== "all") {
+                cohortConstraints.push(where(documentId(), "in", user.visibleCohorts));
+            }
+        }
+        firebaseQuery.collectionSnapshot(setCohorts, "cohorts", cohortConstraints);
+        firebaseQuery.collectionSnapshot(setEmailTemplates, "emailTemplates", [where("product", "==", user.product), where("oId", "==", user.oId)]);
+    }, [user.oId, user.userGroup, user.viewAddresses, user.viewCohorts, user.visibleAddresses, user.visibleCohorts, user.product])
 
     const getJobById = async (id: string) => {
         try {
@@ -135,27 +199,75 @@ 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
-        }
+        },
+        institute,
+        userGroups,
+        forms,
+        cohorts,
+        emailTemplates,
     }
+}
+
+export function useInstitute({user}: {user: UserData}) {
+    if (!user || user?.product !== "institutes") return {error: "Unauthorized"};
+
+    const [userGroups, setUserGroups] = useState<{[key:string]: UserGroupData}>(); 
+    const [forms, setForms] = useState<{[key:string]: unknown}>(); 
+    const [institute, setInstitute] = useState<InstituteData>();
+    const firebaseQuery = new FirebaseQuery();
 
 
+    useEffect(() => {
+        getOrganisation(user, (data) => setInstitute(data as InstituteData));
+        firebaseQuery.collectionSnapshot(setUserGroups, "userGroups", [where("oId", "==", user.oId), where("product", "==", user.product)]);
+        firebaseQuery.collectionSnapshot(setForms, "forms", [where("oId", "==", user.oId), where("product", "==", user.product)]);
+    }, [user.product, user.oId])
+
+    return {
+        userGroups,
+        forms,
+        institute,
+    }
+
 }
 
 export function useInstituteStudent({user}: {user: UserData}) {
-    const {contacts, placements} = useStudent({user});
+    if (!user || user?.product !== "institutes" || user.userType !== "Students") return {error: "Unauthorized"};
 
-    if (!user || user?.product !== "institutes" || user.userType !== "Students") return {};
+    const {contacts, placements, applications} = useStudent({user});
+    const [cohorts, setCohorts] = useState<{[key:string]: CohortData}>(); 
+    const firebaseQuery = new FirebaseQuery();
+    const {userGroups, forms, institute} = useInstitute({user})
+
+    useEffect(() => {
+        const isAdmin = user.userGroup === "admin";
+        const canViewCohorts = user.viewCohorts !== "none";
+        const canViewAddresses = user.viewAddresses !== "none";
+    
+        if (isAdmin || (canViewCohorts && canViewAddresses)) {
+            const cohortConstraints = [where("oId", "==", user.oId)];
+            firebaseQuery.collectionSnapshot(setCohorts, "cohorts", cohortConstraints);
+        } else {
+            setCohorts({});
+        }
+    }, [user.oId, user.id, user.userGroup, user.viewCohorts, user.viewAddresses, user.product]);
 
     return {
         contacts,
-        placements
+        placements,
+        institute,
+        userGroups,
+        forms,
+        cohorts,
+        applications,
     }
 
 }
 
 export function useProvider({user}: {user: UserData}) {
-    if (!user || user?.product !== "providers") return {};
+    if (!user || user?.product !== "providers") return {error: "Unauthorized"};
     
     const {jobs} = useInstituteStaff({user});