placementt-core 11.0.533 → 11.10.151

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

@@ -48,16 +48,18 @@ 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};
 };
 
 

package/src/firebase/firebaseQuery.tsx

@@ -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) => {

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,21 @@ 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]) as UserData;
+        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 +225,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;
             });
         })