placementt-core 11.0.533 → 11.0.892

package/src/features/updates/useUpdates.tsx

@@ -1,22 +1,24 @@
 import FirebaseQuery from "../../firebase/firebaseQuery";
 import {orderBy, limit, arrayUnion} from "firebase/firestore";
-import {useState, useEffect}  from "react";
+import {useState}  from "react";
 import { UserData } from "../../typeDefinitions";
 
 export function useUpdates({user}: {user: UserData}){
    const [active, setActive] = useState<{title: string, body: string, id: string}>();
    const firebaseQuery = new FirebaseQuery();
 
-   useEffect(() => {
-        setTimeout(() => {
-            firebaseQuery.getDocsWhere("updates", [orderBy("created", "desc"), limit(1)]).then((result) => {
-                const item = Object.values(result as {[key:string]: {title: string, body: string, id: string}})[0];
-                if (!user?.readUpdates?.includes(item.id)) {
-                    setActive(item);
-                }
-            })
-        }, 1000);
-    }, []);
+   const fetchUpdates = async () => {
+    try {
+        const docs = await firebaseQuery.getDocsWhere("updates", [orderBy("created", "desc"), limit(1)])
+        const item = Object.values(docs as {[key:string]: {title: string, body: string, id: string}})[0];
+        if (!user?.readUpdates?.includes(item.id)) setActive(item);
+
+    } catch(error) {
+         console.log(error)
+    }
+    
+}
+  
 
     const dismiss = () => {
         if (!user) return
@@ -31,6 +33,6 @@ export function useUpdates({user}: {user: UserData}){
         }
     }
 
-  return ({...{active, dismiss}})
+  return ({...{active, dismiss, fetchUpdates}})
 
 }  

package/src/firebase/firebase.tsx

@@ -5,7 +5,7 @@ import {getUser} from "./readDatabase";
 import {UserData} from "../typeDefinitions";
 import FirebaseQuery from "./firebaseQuery";
 import {auth, functions} from "./firebaseConfig";
-import {addJob, setJobStatus} from "../features/jobs/jobsSlice";
+import {addJob, Job, updateJob} from "../features/jobs/jobsSlice";
 import { useAppDispatch } from "../reduxHooks";
 
 
@@ -17,12 +17,15 @@ export const authListener = (setUser: SetStateAction<any>) => {
             return;
         }
         console.log("User logged in.");
+        if (!aUser.email) {
+            setUser(false);
+            return;
+        };
         getUser(aUser.uid, setUser);
     });
 };
 
 export const login = async (credentials: {email: string, password: string}) => {
-    console.log("creds", credentials);
     return signInWithEmailAndPassword(auth, credentials.email, credentials.password);
 };
 
@@ -40,7 +43,6 @@ export type RegistrationData = {
 }
 
 export const register = async (credentials: RegistrationData, type:"Institute"|"Provider"|"Student") => {
-    console.log("creds", credentials);
     return await executeCallable(`registration-register${type}`, credentials).catch((e) => {
         console.log("Error in regsiter", e);
         throw e;
@@ -48,23 +50,25 @@ export const register = async (credentials: RegistrationData, type:"Institute"|"
         if (type === "Student") {
             await login({email: credentials.email, password: credentials.passwordOne});
         }
-        return (res.data as { message: {uid: string}}).message.uid as string;
+        return (res.data as { msg: {uid: string}}).msg.uid as string;
     });
 };
 
 export const executeCallable = async (functionName: string, data: unknown) => {
     const funcCallable = httpsCallable(functions, functionName);
-    return await funcCallable(data).catch((e) => {
+    const res = await funcCallable(data).catch((e) => {
         console.log("callableError", functionName, e);
-        return e;
+        throw e;
     });
+
+    return res as {data: any};
 };
 
 
 export function useExecuteCallableJob({user}:{user: UserData}) {
     type CallableFunctionJobs = "userManagement-addUsers"|"userManagement-activateUsers"|
     "userManagement-deactivateUsers"|"userManagement-deleteUsers"|"admissions-createCohort"|"userManagement-uploadAnalytics"|
-    "placementListing-add"
+    "providerContacts-add"|"userManagement-sendParentWelcomeEmail"
     const dispatch = useAppDispatch();
 
     const execute = async (functionName:CallableFunctionJobs, data:{[key:string]:unknown}) => {
@@ -93,10 +97,16 @@ export function useExecuteCallableJob({user}:{user: UserData}) {
                     description: `Attempting deletion of ${Array.isArray((data as {users:{[key:string]:unknown}}).users) ?
                         "multiple" : Object.entries((data as {users:{[key: string]: UserData}}).users).length || "multiple"} users.`,
                 };
-            case "placementListing-add":
+            case "providerContacts-add":
                 return {
-                    title: "Adding placements",
-                    description: `Attempting addition of ${(data as {data:[]}).data.length} placements`,
+                    title: "Adding employer contacts",
+                    description: `Attempting addition of ${(data as {providerContacts:[]}).providerContacts.length} employer contacts`,
+                };
+            case "userManagement-sendParentWelcomeEmail":
+                return {
+                    title: "Sending parent welcome emails",
+                    description: `Sending parent welcome emails to ${Array.isArray((data as {users:{[key:string]:unknown}}).users) ?
+                        "multiple" : Object.entries((data as {users:{[key: string]: UserData}}).users).length || "multiple"} users.`,
                 };
             default:
                 return;
@@ -129,13 +139,14 @@ export function useExecuteCallableJob({user}:{user: UserData}) {
 
         const funcCallable = httpsCallable(functions, functionName);
         console.log(items);
-        funcCallable(items).then(() => {
-            dispatch(setJobStatus({
+        funcCallable(items).then(async () => {
+            const jobResolved = await firebaseQuery.getDocData(["jobs", jobId]) as Job;
+            dispatch(updateJob({
                 jobId: jobId,
-                status: "success",
-            }));
+                data: jobResolved
+            } as Partial<Job>));
         });
-        return;
+        return jobId;
     };
 
     return {execute};

package/src/firebase/firebaseConfig.tsx

@@ -35,7 +35,7 @@ initializeAuth(firebaseConfig, {
 
 initializeFirestore(firebaseConfig, {
     ignoreUndefinedProperties: true,
-})
+});
 
 export const auth = getAuth(firebaseConfig);
 export const db = getFirestore(firebaseConfig);

package/src/firebase/firebaseQuery.tsx

@@ -53,14 +53,14 @@ export default class FirebaseQuery {
         await deleteDoc(this.createQuery("doc", path) as DocumentReference);
     }
 
-    async copy(path: string[]|string, id: string, oId: string, product: Products) {
+    async copy(path: string[]|string, id: string, oId: string, product: Products, additionalData?: {[key: string]: unknown}) {
         const existing = await this.getDocData([...path, id]);
         console.log("existing", existing);
         existing.name = await this.getUniqueDocName(path, existing.name, oId, product);
         if (existing.default) {
             existing.default = false;
         }
-        return await this.add(path, existing);
+        return await this.add(path, {...existing, ...additionalData});
     }
 
     async getUniqueDocName(path: string[]|string, name: string, oId: string, product: Products): Promise<string> {
@@ -82,6 +82,9 @@ export default class FirebaseQuery {
             console.log(`Error in snapshot ${path}`, error);
             throw error;
         });
+        if (!result.exists()) {
+            throw new Error(`Document doesn't exist. ${typeof path === "string" ? path : path.join(", ")}`);
+        }
         const resultData = result.data() || {};
         resultData.id = result.id;
         return resultData;
@@ -124,10 +127,14 @@ export default class FirebaseQuery {
         });
     }
 
-    collectionSnapshot(setState:SetStateAction<any>, path: string[]|string, constraints?:QueryConstraint[]|QueryConstraint, dispatch?: AppDispatch) {
+    collectionSnapshot(setState:SetStateAction<any>|((e: DocumentData|{[key: string]: any}) => void), path: string[]|string, constraints?:QueryConstraint[]|QueryConstraint, dispatch?: AppDispatch, raw?: boolean) {
         const q = this.createQuery("collection", path, constraints) as Query<DocumentData>;
 
         return onSnapshot(q, (querySnapshot: DocumentData) => {
+            if (raw) {
+                setState(querySnapshot);
+                return;
+            }
             const itemList: {[key: string]: any} = {};
 
             querySnapshot.docs.forEach((doc: QueryDocumentSnapshot) => {
@@ -138,6 +145,7 @@ export default class FirebaseQuery {
             dispatch ? dispatch(setState(itemList)) : setState(itemList);
         }, (error) => {
             console.log(`Error in snapshot ${path}`, error);
+            console.log(constraints)
         });
     }
 }

package/src/firebase/readDatabase.tsx

@@ -1,7 +1,7 @@
 import {collection, getDocs, limit, orderBy, query, QueryConstraint, where} from "firebase/firestore";
 import {getDownloadURL, listAll, ref, StorageReference} from "firebase/storage";
 import {SetStateAction} from "react";
-import {CohortData, InstituteData, NotificationObject, PlacementListing, ProviderData, UserData, UserGroupData} from "../typeDefinitions";
+import {BillingPackage, CohortData, InstituteData, NotificationObject, PlacementListing, ProviderData, UserData, UserGroupData} from "../typeDefinitions";
 import {db, storage} from "./firebaseConfig";
 import FirebaseQuery from "./firebaseQuery";
 import {pathToArr, sortByReverseStringLength} from "./util";
@@ -76,6 +76,7 @@ export const getUser = async (uid: string, setState: SetStateAction<any>) => {
     let oldUser:OldUserData = {};
     let groupData = {};
     let cohortData = {};
+    let packageData = {};
 
     console.log("Fetching user");
 
@@ -89,6 +90,15 @@ export const getUser = async (uid: string, setState: SetStateAction<any>) => {
         }
         user.groupData = groupData as UserGroupData;
 
+        // if (user.product === "providers") {
+        //     // Always set the groupData, but only get it if the user group has changed.keyof
+        //     if (oldUser?.userGroup !== user.userGroup) {
+        //         const provider = await firebaseQuery.getDocData(["providers", user.oId]) as ProviderData;
+        //         packageData = await firebaseQuery.getDocData(["billing", provider.package]) as BillingPackage;
+        //     }
+        // }
+        user.packageData = packageData as BillingPackage;
+
         if (user.cohort) {
             // Always set the groupData, but only get it if the user group has changed.keyof
             if (oldUser?.cohort !== user.cohort) {
@@ -170,8 +180,22 @@ export const getFormsFromId = async (path: string[]|string, forms: string[]) =>
     }, Promise.resolve({}))));
 };
 
-export const getUserById = async (id: string) => {
-    return await firebaseQuery.getDocData(["users", id]) as UserData;
+export const getUserById = async (id: string, setState?: SetStateAction<any>, getGroupData=true) => {
+    if (!setState) {
+        const user =  await firebaseQuery.getDocData(["users", id]).catch(() => false) as UserData|false;
+        if (!user) return;
+        if (getGroupData) {
+            user.groupData = user.userGroup && user.userGroup !== "admin" ? await firebaseQuery.getDocData(["userGroups", user.userGroup]) as UserGroupData : undefined
+        }
+        return user;
+    }
+    firebaseQuery.documentSnapshot(["users", id], async (user: UserData) => {
+        if (getGroupData) {
+            user.groupData = user.userGroup && user.userGroup !== "admin" ? await firebaseQuery.getDocData(["userGroups", user.userGroup]) as UserGroupData : undefined
+        }
+        setState(user);
+    });
+    return;
 };
 
 /* export const getUsersByType = async (q: Query, setState:SetStateAction<any>, uid:string, lim:number, limitType?:"start"|"end") => {
@@ -202,7 +226,11 @@ export const checkPlacementConflicts = async (instituteId:string, userGroupId:st
 };
 
 export const getPlacementListingsById = async (placementListings: string[]) => {
-    return Object.fromEntries(await Promise.all(placementListings.map(async (listingId) => {
-        return [listingId, await firebaseQuery.getDocData(["placementListings", listingId]) as PlacementListing];
-    })) as [string, PlacementListing][]);
+    const placements =  await Promise.all(placementListings.map(async (listingId) => {
+        return [listingId, await firebaseQuery.getDocData(["placementListings", listingId]).catch(() => false) as PlacementListing];
+    })) as [string, PlacementListing|false][];
+
+    return placements.filter(([_, v]) => v !== false) as [string, PlacementListing][];
 }
+
+

package/src/firebase/writeDatabase.tsx

@@ -24,6 +24,8 @@ export const uploadFiles = async (files: any[]|any, path: string[] | string, fil
 
             const storageRef = ref(storage, newPath);
 
+            console.log("FILE ELEMENT", element);
+
             if (typeof element === "string") {
                 return await uploadString(storageRef, element, "base64", fileType ? {contentType: fileType} : undefined)
                 .catch((e) => {
@@ -31,7 +33,7 @@ export const uploadFiles = async (files: any[]|any, path: string[] | string, fil
                 });
             }
 
-            await uploadBytes(storageRef, element).catch((e) => {
+            return await uploadBytes(storageRef, element).catch((e) => {
                 final = e;
             });
         })