placementt-core 11.0.533 → 11.10.151

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 { 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, address: Address}}>();
     const firebaseQuery = new FirebaseQuery();
     
     const dispatch = useAppDispatch();
@@ -42,8 +44,8 @@ export function useStudent({user} : {user: UserData}) {
 
             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 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 || {},

package/src/tasksAndTips.ts

@@ -1,7 +1,7 @@
 import {arrayUnion, orderBy, where} from "firebase/firestore";
 import FirebaseQuery from "./firebase/firebaseQuery";
-import {CohortData, InstituteData, ProviderData, StudentPlacementData, UserData} from "./typeDefinitions";
-import {getAccess} from "./firebase/util";
+import {CohortData, InstituteData, OrganisationAddress, PlacementListing, ProviderData, RegistrationRequest, StudentPlacementData, UserData} from "./typeDefinitions";
+import {camelCaseToNormal, capitaliseWords, dateToString, getAccess} from "./firebase/util";
 import { convertDate } from "./firebase/util";
 
 const firebaseQuery = new FirebaseQuery;
@@ -12,7 +12,7 @@ type StudentTipNames = string
 
 export type InstituteTaskNames = "missingParentEmail"|"verifyInsurance"|"verifyRiskAssessment"|"verifyDbsCheck"|"inactiveStudents"|"uploadStudents"|"inactiveStaff"|"requiredStage"|"approveExternalPlacement"|"overdueStage"
 export type StudentTaskNames = "completeOnboarding"
-export type ProviderTaskNames = "applicationRequireReview"|"requestedVisiblePlacementListings"|"requestedVisibleAddresses"|"completeStudentDocs"|"reviewOnboarding"|"completeListing"|"completeAddress"|"registrationRequests"|"placementStarting"|"completeFeedback"|"setUpFeedback"
+export type ProviderTaskNames = "applicationRequireReview"|"activateStaff"|"requestedVisiblePlacementListings"|"requestedVisibleAddresses"|"completeStudentDocs"|"uploadOnboarding"|"reviewOnboarding"|"completeListing"|"completeAddress"|"registrationRequests"|"placementStarting"|"completeFeedback"|"setUpFeedback"
 
 // IF UPDATING LOGIC WITHIN THIS FILE, PLACEMENTT-BACKEND LOGIC MUST ALSO BE CHANGED ACCORDINGLY
 
@@ -511,10 +511,11 @@ const studentTasks:StudentTaskObject = {
 const providerTasks:ProviderTaskObject = {
     requestedVisibleAddresses: {
         callback: async (user) => {
-            const accessRequests = await firebaseQuery.getCount("users", [where("oId", "==", user.oId), where("product", "==", "providers"), orderBy("requestedVisibleAddresses")]);
+            if (!getAccess(user, "addStaff")) return;
+            const accessRequests = await firebaseQuery.getCount("users", [where("oId", "==", user.oId), where("product", "==", "providers"), orderBy("requestedVisibleAddresses")]) - ((Array.isArray(user?.requestedVisibleAddresses) && user?.requestedVisibleAddresses.length > 0) ? 1 : 0);
             if (accessRequests === 0) return;
             if (accessRequests === 1) {
-                const userRequestingAccess = Object.entries(await firebaseQuery.getDocsWhere("users", [where("oId", "==", user.oId), where("product", "==", "providers"), orderBy("requestedVisibleAddresses")]) || {})[0] as [string, UserData];
+                const userRequestingAccess = Object.entries(await firebaseQuery.getDocsWhere("users", [where("product", "==", "providers"), where("oId", "==", user.oId), orderBy("requestedVisibleAddresses")]) || {})[0] as [string, UserData];
                 return {
                     dismissible: false,
                     severity: "primary",
@@ -537,7 +538,8 @@ const providerTasks:ProviderTaskObject = {
     },
     requestedVisiblePlacementListings: {
         callback: async (user) => {
-            const accessRequests = await firebaseQuery.getCount("users", [where("oId", "==", user.oId), where("product", "==", "providers"), orderBy("requestedVisibleListings")]);
+            if (!getAccess(user, "addStaff")) return;
+            const accessRequests = await firebaseQuery.getCount("users", [where("oId", "==", user.oId), where("product", "==", "providers"), orderBy("requestedVisibleListings")])- ((Array.isArray(user?.requestedVisibleListings) && user?.requestedVisibleListings.length > 0) ? 1 : 0);;
             if (accessRequests === 0) return;
             if (accessRequests === 1) {
                 const userRequestingAccess = Object.entries(await firebaseQuery.getDocsWhere("users", [where("oId", "==", user.oId), where("product", "==", "providers"), orderBy("requestedVisibleListings")]) || {})[0] as [string, UserData];
@@ -578,41 +580,212 @@ const providerTasks:ProviderTaskObject = {
     },
     completeStudentDocs: {
         callback: async (user) => {
+            return;
             return {} as TaskQueryReturnObject;
         },
     },
     reviewOnboarding: {
         callback: async (user) => {
-            return {} as TaskQueryReturnObject;
+            const toReview = await firebaseQuery.getCount("placements", [where("providerId", "==", user.oId), where("onboarding.completed.accepted", "==", false), where("onboarding.completed.submitted", "==", true), where("endDate", ">=", dateToString(new Date()))]);
+            
+            if (toReview === 0) return;
+            if (toReview === 1) {
+                const placement = Object.entries(await firebaseQuery.getDocsWhere("placements", [where("providerId", "==", user.oId), where("onboarding.completed.accepted", "==", false), where("onboarding.completed.submitted", "==", true), where("endDate", ">=", dateToString(new Date()))]) || {})[0] as [string, StudentPlacementData];
+                const student = await firebaseQuery.getDocData(["users", placement[1].uid]) as UserData;
+                return {
+                    dismissible: false,
+                    severity: "primary",
+                    title: `${student.details.forename} ${student.details.surname} has completed their onboarding for their placement from ${convertDate(placement[1].startDate, "visual")} to ${convertDate(placement[1].endDate, "visual")}`,
+                    message: `Click to view the placement and review the onboarding.`,
+                    link: `/${user.product}/placements/${placement[0]}`,
+                    buttonTitle: "View",
+                } as TaskQueryReturnObject;
+        }
+
+            return {
+                dismissible: false,
+                severity: "primary",
+                title: `${toReview} student have completed their onboarding.`,
+                message: `Click to view your placements and approve completed onboarding`,
+                link: `/${user.product}/placementListings/placements`,
+                buttonTitle: "View placements",
+            } as TaskQueryReturnObject;
+        },
+    },
+    uploadOnboarding: {
+        callback: async (user) => {
+            const withoutOnboarding = await firebaseQuery.getCount("placements", [where("providerId", "==", user.oId), where("onboarding", "==", null), where("endDate", ">=", dateToString(new Date()))]);
+            
+            if (withoutOnboarding === 0) return;
+            if (withoutOnboarding === 1) {
+                const placement = Object.entries(await firebaseQuery.getDocsWhere("placements", [where("providerId", "==", user.oId), where("onboarding", "==", null), where("endDate", ">=", dateToString(new Date()))]) || {})[0] as [string, StudentPlacementData];
+                const student = await firebaseQuery.getDocData(["users", placement[1].uid]) as UserData;
+                return {
+                    dismissible: false,
+                    severity: "primary",
+                    title: `Send onboarding documents to ${student.details.forename} ${student.details.surname}'s placement from ${convertDate(placement[1].startDate, "visual")} to ${convertDate(placement[1].endDate, "visual")}`,
+                    message: `Click to view the placement and add or dismiss onboarding reminders.`,
+                    link: `/${user.product}/placements/${placement[0]}`,
+                    buttonTitle: "View",
+                } as TaskQueryReturnObject;
+        }
+
+            return {
+                dismissible: false,
+                severity: "primary",
+                title: `Set up onboarding for ${withoutOnboarding} placements to prepare yourself and your students.`,
+                message: `Click to view your placements and add or dismiss onboarding reminders.`,
+                link: `/${user.product}/placementListings/placements`,
+                buttonTitle: "View placements",
+            } as TaskQueryReturnObject;
         },
     },
     completeListing: {
         callback: async (user) => {
-            return {} as TaskQueryReturnObject;
+            const incompleteListings = await firebaseQuery.getCount("placementListings", [where("providerId", "==", user.oId), where("status", "==", "draft")]);
+            if (incompleteListings === 0) return;
+            if (incompleteListings === 1) {
+                const incompleteListing = Object.entries(await firebaseQuery.getDocsWhere("placementListings", [where("providerId", "==", user.oId), where("status", "==", "draft")]) || {})[0] as [string, PlacementListing];
+                const address = incompleteListing[1].addressId ? await firebaseQuery.getDocData(["addresses", incompleteListing[1].addressId]) as OrganisationAddress : undefined;
+                return {
+                    dismissible: false,
+                    severity: "info",
+                    title: `Your listing '${incompleteListing[1].title || "unnamed"}' at ${address ? `${address["address-line1"]}, ${address.postal_code.toUpperCase()}, ${capitaliseWords(camelCaseToNormal(address.country))}` : "unknown address"} requires more information before publishing.`,
+                    message: `Click to complete and publish the placement listing.`,
+                    link: `/${user.product}/addListing/${incompleteListing[0]}`,
+                    buttonTitle: "View listing",
+                } as TaskQueryReturnObject;
+        }
+
+            return {
+                dismissible: false,
+                severity: "info",
+                title: `You have ${incompleteListings} draft listings waiting to be published.`,
+                message: `Click to review and publish the placement listings.`,
+                link: `/${user.product}/placementListings/listings`,
+                buttonTitle: "View listings",
+            } as TaskQueryReturnObject;
         },
     },
     completeAddress: {
         callback: async (user) => {
-            return {} as TaskQueryReturnObject;
+            const incompleteAddresses = await firebaseQuery.getCount("addresses", [where("product", "==", "providers"), where("oId", "==", user.oId), where("stage", "!=", "complete")]);
+            if (incompleteAddresses === 0) return;
+            if (incompleteAddresses === 1) {
+                const address = Object.entries(await firebaseQuery.getDocsWhere("addresses", [where("product", "==", "providers"), where("oId", "==", user.oId), where("stage", "!=", "complete")]) || {})[0] as [string, OrganisationAddress];
+                return {
+                    dismissible: false,
+                    severity: "info",
+                    title: `Your address: ${address[1]["address-line1"]}, ${address[1].postal_code.toUpperCase()}, ${capitaliseWords(camelCaseToNormal(address[1].country))} is currently incomplete.`,
+                    message: `Click to complete the addresses.`,
+                    link: `/${user.product}/addAddress/${address[0]}`,
+                    buttonTitle: "View address",
+                } as TaskQueryReturnObject;
+        }
+
+            return {
+                dismissible: false,
+                severity: "info",
+                title: `You have ${incompleteAddresses} draft addresses waiting to be published.`,
+                message: `Click to review the addresses.`,
+                link: `/${user.product}/organisation/addresses`,
+                buttonTitle: "View addresses",
+            } as TaskQueryReturnObject;
         },
     },
     registrationRequests: {
         callback: async (user) => {
-            return {} as TaskQueryReturnObject;
+            const regRequests = await firebaseQuery.getCount("requests", [where("product", "==", user.product), where("oId", "==", user.oId)]);
+
+            if (regRequests === 0) return;
+            if (regRequests === 1) {
+                const request = Object.entries(await firebaseQuery.getDocsWhere("requests", [where("product", "==", user.product), where("oId", "==", user.oId)]) || {})[0] as [string, RegistrationRequest];
+                return {
+                    dismissible: false,
+                    severity: "primary",
+                    title: `${request[1].forename} ${request[1].surname} has requested to access your organisation.`,
+                    message: `Click to review these request.`,
+                    link: `/${user.product}/organisation/staff/requests`,
+                    buttonTitle: "View requests",
+                } as TaskQueryReturnObject;
+        }
+
+            return {
+                dismissible: false,
+                severity: "primary",
+                title: `${regRequests} people have requested to register with your organisation.`,
+                message: `Click to review these requests.`,
+                link: `/${user.product}/organisation/staff/requests`,
+                buttonTitle: "View requests",
+            } as TaskQueryReturnObject;
+        },
+    },
+    activateStaff: {
+        callback: async (user) => {
+            const inactiveAccounts = await firebaseQuery.getCount("users", [where("product", "==", user.product), where("oId", "==", user.oId), where("status", "==", "inactive")]);
+
+            if (inactiveAccounts === 0) return;
+            if (inactiveAccounts === 1) {
+                const account = Object.entries(await firebaseQuery.getDocsWhere("users", [where("product", "==", user.product), where("oId", "==", user.oId), where("status", "==", "inactive")]) || {})[0] as [string, UserData];
+                return {
+                    dismissible: false,
+                    severity: "info",
+                    title: `Activate ${account[1].details.forename} ${account[1].details.surname}'s staff account.`,
+                    message: "Activate this account to give the user access to Placementt.",
+                    link: `/${user.product}/organisation/staff/all`,
+                    buttonTitle: "View accounts",
+                } as TaskQueryReturnObject;
+        }
+
+            return {
+                dismissible: false,
+                severity: "info",
+                title: `${inactiveAccounts} staff have inactive active accounts.`,
+                message: "Activate these accounts to give the user access to Placementt.",
+                link: `/${user.product}/organisation/staff/all`,
+                buttonTitle: "View accounts",
+            } as TaskQueryReturnObject;
         },
     },
     placementStarting: {
         callback: async (user) => {
-            return {} as TaskQueryReturnObject;
+            const sevenDaysInFuture = new Date();
+            sevenDaysInFuture.setDate(sevenDaysInFuture.getDate() + 7)
+            const placementsStartingSoon = await firebaseQuery.getCount("placements", [where("providerId", "==", user.oId), where("startDate", "<=", convertDate(sevenDaysInFuture, "dbstring")), where("startDate", ">", dateToString(new Date()))]);
+            
+            if (placementsStartingSoon === 0) return;
+            if (placementsStartingSoon === 1) {
+                const placement = Object.entries(await firebaseQuery.getDocsWhere("placements", [where("providerId", "==", user.oId), where("startDate", "<=", convertDate(sevenDaysInFuture, "dbstring")), where("startDate", ">", dateToString(new Date()))]) || {})[0] as [string, StudentPlacementData];
+                const student = await firebaseQuery.getDocData(["users", placement[1].uid]) as UserData;
+                return {
+                    dismissible: false,
+                    severity: "success",
+                    title: `${student.details.forename} ${student.details.surname}'s placement from ${convertDate(placement[1].startDate, "visual")} to ${convertDate(placement[1].endDate, "visual")} is starting in less than a week.`,
+                    message: `Click to view the placement and acquaint yourself with the student.`,
+                    link: `/${user.product}/placements/${placement[0]}`,
+                    buttonTitle: "View",
+                } as TaskQueryReturnObject;
+        }
+
+            return {
+                dismissible: false,
+                severity: "success",
+                title: `${placementsStartingSoon} placements starting soon.`,
+                message: `Click to view scheduled placements.`,
+                link: `/${user.product}/placementListings/placements`,
+                buttonTitle: "View placements",
+            } as TaskQueryReturnObject;
         },
     },
     completeFeedback: {
         callback: async (user) => {
+            return;
             return {} as TaskQueryReturnObject;
         },
     },
     setUpFeedback: {
         callback: async (user) => {
+            return;
             return {} as TaskQueryReturnObject;
         },
     },

package/src/typeDefinitions.ts

@@ -85,13 +85,15 @@ export type StudentPlacementData = {
         },
     },
     onboarding: (OnboardingDocs&{
+        deadline?: string,
         completed: {
-            submitted: string|false,
+            submitted: boolean,
+            submittedDate?: string,
             accepted?: boolean,
             filesViewed?: string[],
             formsCompleted?: {[key: string]: unknown},
             filesUploaded?: {[key: number]: string[]},
-        }})|false,
+        }})|false|null,
 }
 
 export type PlacementQuestions = {
@@ -178,29 +180,17 @@ export type PlacementListing = {
     applicationType?: "simple"|"complex",
     applicantWorkflowId?: string,
     applicantWorkflow?: ApplicantStage[],
-    onboarding: OnboardingDocs|false,
+    onboarding: (OnboardingDocs&{deadline: number})|false,
     maxApplicants?: number,
     maxStudents?: number,
     primaryContactId: string,
 }
 
 export type OnboardingDocs = {
-    deadline?: string,
     message?: string,
-    deadlineType?: "date"|"days"
     forms?: string[],
     files?: string[],
-    formDetails?: {[key: string]:
-        {
-            name: string,
-            id: string,
-            description?: string,
-            product: Products,
-            oId: string,
-            form: CustomFormSchema
-        }},
     requiredFiles?: {fileName: string, fileType: string}[]
-    viewableFiles?: {[key: string]: FileItem},
 }
 
 export type PlacementTemplate = PlacementListing&{templateName: string};
@@ -273,13 +263,15 @@ export type FlagCodes =
     "completeOnboarding"|
     "reviewOnboarding"|
     "requestedVisibleAddresses"|
-    "requestedVisiblePlacementListings"
+    "requestedVisiblePlacementListings"|
+    "addOnboarding"
 
 
 export type UserData = {
     details: {
         forename: string,
         surname: string,
+        pronouns?: string,
         parentEmail?: string,
         year?: string
     },
@@ -318,7 +310,7 @@ export type UserData = {
     visibleCohorts?: string,
     readUpdates?: string[],
     contactProviderConsent?: boolean,
-    contactProviderConsenDate?: boolean
+    contactProviderConsentDate?: boolean
     referrals?: number,
     shareNameWithReferralLeaderboardConsent?: boolean,
     shareNameWithReferralLeaderboardConsentDate?: boolean,
@@ -329,7 +321,8 @@ export type UserData = {
     visibleAddresses?: string[],
     visibleListings?: string[],
     requestedVisibleAddresses?: string[],
-    requestedVisibleListings?: string[]
+    requestedVisibleListings?: string[],
+    packageData?: BillingPackage
 };
 
 export type AnalyticsItem = {
@@ -497,7 +490,7 @@ export type ProviderData = {
     staffActive: number,
     admin: string,
     name: string,
-    insurance: boolean,
+    insurance: boolean|"awaitingReview",
     regNumber?: string,
     insuranceExpiry: string,
     mapConsent?: boolean|"unlisted",
@@ -525,7 +518,7 @@ export type ProviderData = {
         locations?: number,
     },
     discount?: string,
-    package?: string,
+    package: string,
     splitBilling?: boolean,
     adminBillingContactId: string,
     addOnPackages?: string[],
@@ -829,6 +822,7 @@ export type Application = {
     uid: string,
     applicantWorkflowId: string,
     listingId: string,
+    addressId: string,
     providerId: string,
     reqUserType: "Students"|"Staff",
     completedSections: {[stage: number]: {

package/src/util.ts

@@ -32,51 +32,57 @@ export const getPlacementFlagCodes = ({placement, studentData, workflow, institu
     const dbsCheckNotVerified = !institute?.verifiedDbsChecks?.includes(placement.placementId || placement.id);
     const awaitingDbsCheck = !placement.dbsCheck || institute?.awaitingPlacementDbsChecks?.includes(placement.placementId || placement.id);
 
-    if (user.userType === "Staff" && placement.insurance && placementIsPostProviderReview && placementNotEnded && providerUnverified && !awaitingProviderInsurance) {
+    if (user.userType === "Staff" && user.product === "institutes" && placement.insurance && placementIsPostProviderReview && placementNotEnded && providerUnverified && !awaitingProviderInsurance) {
         console.log("Add insurance flag!");
         flags.includes("noInsurance") || flags.push("noInsurance");
     } else {
         flags = flags.filter((x) => x !== "noInsurance");
     }
 
-    if (user.userType === "Staff" && placementIsPostProviderReview && placementNotEnded && awaitingProviderInsurance) {
+    if (user.userType === "Staff" && user.product === "institutes" && placementIsPostProviderReview && placementNotEnded && awaitingProviderInsurance) {
         flags.includes("awaitingInsurance") || flags.push("awaitingInsurance");
     } else {
         flags = flags.filter((x) => x !== "awaitingInsurance");
     }
 
-    if (user.userType === "Staff" && placement.dbsCheck && workflow.find((stage) => stage.dbsCheck) && placement.dbsCheck !== true && placementIsPostProviderReview && placementNotEnded && dbsCheckNotVerified && !awaitingDbsCheck) {
+    if (user.userType === "Staff" && user.product === "institutes" && placement.dbsCheck && workflow.find((stage) => stage.dbsCheck) && placement.dbsCheck !== true && placementIsPostProviderReview && placementNotEnded && dbsCheckNotVerified && !awaitingDbsCheck) {
         flags.includes("noDbsCheck") || flags.push("noDbsCheck");
     } else {
         flags = flags.filter((x) => x !== "noDbsCheck");
     }
 
-    if (user.userType === "Staff" && placementIsPostProviderReview && workflow.find((stage) => stage.dbsCheck) && placementNotEnded && awaitingProviderInsurance) {
+    if (user.userType === "Staff" && user.product === "institutes" && placementIsPostProviderReview && workflow.find((stage) => stage.dbsCheck) && placementNotEnded && awaitingProviderInsurance) {
         flags.includes("awaitingDbsCheck") || flags.push("awaitingDbsCheck");
     } else {
         flags = flags.filter((x) => x !== "awaitingDbsCheck");
     }
 
-    if (user.userType === "Staff" && placement.riskAssessment && workflow.find((stage) => stage.riskAssessment) && placement.riskAssessment !== true && placementIsPostProviderReview && placementNotEnded && riskAssessmentNotVerified && !awaitingRiskAssessment) {
+    if (user.userType === "Staff" && user.product === "institutes" && placement.riskAssessment && workflow.find((stage) => stage.riskAssessment) && placement.riskAssessment !== true && placementIsPostProviderReview && placementNotEnded && riskAssessmentNotVerified && !awaitingRiskAssessment) {
         console.log("Add RA flag!");
         flags.includes("noRiskAssessment") || flags.push("noRiskAssessment");
     } else {
         flags = flags.filter((x) => x !== "noRiskAssessment");
     }
 
-    if (user.userType === "Staff" && placementIsPostProviderReview && workflow.find((stage) => stage.riskAssessment) && placementNotEnded && awaitingProviderInsurance) {
+    if (user.userType === "Staff" && user.product === "institutes" && placementIsPostProviderReview && workflow.find((stage) => stage.riskAssessment) && placementNotEnded && awaitingProviderInsurance) {
         flags.includes("awaitingRiskAssessment") || flags.push("awaitingRiskAssessment");
     } else {
         flags = flags.filter((x) => x !== "awaitingRiskAssessment");
     }
 
-    if (user.userType === "Staff" && user.product === "providers" && user.oId === placement.providerId && placement.onboarding && (placement.onboarding.completed?.submitted && !placement.onboarding.completed.accepted) && (placement.inProgress || placement.active)) {
+    if (placement.inProgress && user.userType === "Staff" && user.product === "providers" && user.oId === placement.providerId && placement.onboarding === null) {
+        flags.includes("addOnboarding") || flags.push("addOnboarding");
+    } else {
+        flags = flags.filter((x) => x !== "addOnboarding");
+    }
+
+    if (placement.inProgress && user.userType === "Staff" && user.product === "providers" && user.oId === placement.providerId && placement.onboarding && (placement.onboarding.completed?.submitted && !placement.onboarding.completed.accepted) && (placement.inProgress || placement.active)) {
         flags.includes("reviewOnboarding") || flags.push("reviewOnboarding");
     } else {
         flags = flags.filter((x) => x !== "reviewOnboarding");
     }
 
-    if (user.userType === "Students" && placement.onboarding && (!placement.onboarding.completed || (placement.onboarding.completed && !placement.onboarding.completed?.submitted)) && (placement.inProgress || placement.active)) {
+    if (placement.inProgress && user.userType === "Students" && placement.onboarding && (!placement.onboarding.completed || (placement.onboarding.completed && !placement.onboarding.completed?.submitted)) && (placement.inProgress || placement.active)) {
         flags.includes("completeOnboarding") || flags.push("completeOnboarding");
     } else {
         flags = flags.filter((x) => x !== "completeOnboarding");
@@ -87,7 +93,6 @@ export const getPlacementFlagCodes = ({placement, studentData, workflow, institu
 };
 
 
-
 export function objectsEqualNew(a: any, b: any): boolean { // Works with arrays or objects.
     if (a === b) {
         return true;