placementt-core 1.20.196 → 11.0.533

package/src/tasksAndTips.ts

@@ -1,410 +1,744 @@
-import {arrayUnion, where} from "firebase/firestore";
-import FirebaseQuery from "./firebase/firebaseQuery";
-import {CohortData, InstituteData, ProviderData, UserData} from "./typeDefinitions";
-
-const firebaseQuery = new FirebaseQuery;
-
-type TipNames = "createCohort"|"uploadStaff"|"assignStaffRoles"|"uploadStudents"|"uploadPlacements"|"allowExternalPlacementUpload"|"uploadStaffGuidance"|"uploadStudentGuidance"
-type TaskNames = "missingParentEmail"|"verifyInsurance"|"inactiveStudents"|"inactiveStaff"|"requiredStage"|"approveExternalPlacement"|"overdueStage"
-
-// type TaskNamesToInclude = "uploadUsers"|"uploadPlacements"|"allowExternalPlacementUpload"|"verifyInsurance"|"requiredStage"|"missingParentEmail"|"overdueStage"
-
-export type TaskQueryReturnObject = {
-    itemName?: TaskNames|TipNames,
-    title?: string,
-    message?: string,
-    link?: string,
-    buttonTitle?: string,
-    dismissible?: boolean,
-    severity?: "error"|"warning"|"success"|"primary"|"info"
-}|undefined;
-/*
-type TasksObject = {
-    [key in TaskNames]: {
-        callback: (user: UserData) => Promise<TaskQueryReturnObject>,
-    };
-};
-*/
-type TipsObject = {
-    [key in TipNames]: {
-        callback: (user: UserData, organisation:InstituteData|ProviderData, cohort: CohortData|[string, CohortData][]) => Promise<TaskQueryReturnObject|TaskQueryReturnObject[]>,
-    };
-};
-
-type TaskObject = {
-    [key in TaskNames]: {
-        callback: (user: UserData, organisation:InstituteData|ProviderData, cohort: CohortData|[string, CohortData][]) => Promise<TaskQueryReturnObject|TaskQueryReturnObject[]>,
-    };
-};
-
-const tips:TipsObject = {
-    createCohort: {
-        callback: async (user, _, cohorts) => {
-            if (!Array.isArray(cohorts)) return;
-            const returnObj: TaskQueryReturnObject = {
-                link: "",
-                dismissible: true,
-            };
-            if (!cohorts.length) {
-                return {
-                    ...returnObj,
-                    title: "Create a cohort",
-                    message: "Create a cohort to manage your students, process their placements and track their progress",
-                    link: "/institutes/cohorts/new",
-                    buttonTitle: "Create cohort",
-                };
-            }
-            return;
-        },
-    },
-    uploadStaff: {
-        callback: async (user) => {
-            const returnObj: TaskQueryReturnObject = {
-                link: "",
-                dismissible: true,
-            };
-            if ((await firebaseQuery.getCount(["users"], [where("oId", "==", user.oId), where("userType", "==", "Staff")])) == 1) {
-                return {
-                    ...returnObj,
-                    title: "Upload staff",
-                    message: "Upload staff to help manage your students",
-                    link: "/institutes/cohorts/staff/all",
-                    buttonTitle: "Upload staff",
-                };
-            }
-            return;
-        },
-    },
-    assignStaffRoles: {
-        callback: async () => {
-            return undefined;
-        },
-    },
-    uploadStudents: {
-        callback: async (user, _, cohorts) => {
-            if (!Array.isArray(cohorts)) return;
-            if (user.product !== "institutes") return;
-            const returnObj: TaskQueryReturnObject = {
-                link: "",
-                dismissible: true,
-            };
-            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
-                const studentCount = (await firebaseQuery.getCount(["users"], [where("oId", "==", user.oId), where("userType", "==", "Students"), where("cohort", "==", id)]));
-                if (studentCount === 0) {
-                    return {
-                        ...returnObj,
-                        title: "Upload students",
-                        message: `Your cohort '${cohort.name}' has no students. Add them in the cohort 'Students' tab`,
-                        link: `/institutes/cohorts/${id}/students`,
-                        buttonTitle: "Upload students",
-                    };
-                }
-                return;
-            }));
-            return items.filter((v) => v);
-        },
-    },
-    uploadPlacements: {
-        callback: async (user) => {
-            const returnObj: TaskQueryReturnObject = {
-                link: "",
-                dismissible: true,
-            };
-            if (await firebaseQuery.getCount(["placementListings"], where(`savedBy.${user.oId}.exists`, "==", true)) === 0) {
-                return {
-                    ...returnObj,
-                    title: "List placements",
-                    message: "You can list placements to students, to give them places to contact. Check out the 'Placements' tab to list opportunitites.",
-                    link: "/institutes/placements",
-                    buttonTitle: "Add placements",
-                };
-            }
-            return;
-        },
-    },
-    allowExternalPlacementUpload: {
-        callback: async (user, organisation) => {
-            if (user.product !== "institutes") return;
-            if ((organisation as InstituteData).externalProviderUploads) return;
-
-            return {
-                dismissible: true,
-                title: "Allow external uploads",
-                message: "Get a link to share with businesses, allowing them to list their own opportunities to your students.",
-                link: "/institutes/placements",
-                buttonTitle: "View placements",
-            };
-        },
-    },
-    uploadStaffGuidance: {
-        callback: async (user, organisation) => {
-            if (user.product !== "institutes") return;
-            const returnObj: TaskQueryReturnObject = {
-                link: "",
-                dismissible: true,
-            };
-            const guidanceTips:TaskQueryReturnObject[] = [];
-            if (!Object.keys((organisation as InstituteData).staffGuidance || {}).length) {
-                guidanceTips.push({
-                    ...returnObj,
-                    title: "Upload staff guidance",
-                    message: "Upload guidance documents to support your staff in coordinating work experience.",
-                    buttonTitle: "Staff guidance",
-                    link: `/${user.product}/setup/guidance`,
-                });
-            }
-            return guidanceTips;
-        },
-    },
-    uploadStudentGuidance: {
-        callback: async (user, organisation) => {
-            if (user.product !== "institutes") return;
-            const returnObj: TaskQueryReturnObject = {
-                link: "",
-                dismissible: true,
-            };
-            const guidanceTips:TaskQueryReturnObject[] = [];
-            if (!Object.keys((organisation as InstituteData).studentsGuidance || {}).length) {
-                guidanceTips.push({
-                    ...returnObj,
-                    title: "Upload student guidance",
-                    message: "Upload guidance documents to support your staff in preparing for their placements.",
-                    buttonTitle: "Student guidance",
-                    link: `/${user.product}/setup/guidance`,
-                });
-            }
-            return guidanceTips;
-        },
-    },
-};
-//  Accept a cohort to any task
-
-const tasks:TaskObject = {
-    requiredStage: {
-        callback: async (user, _, cohorts) => {
-            if (!Array.isArray(cohorts)) {
-                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", cohorts.id), where("reqUserType", "==", user.userType)]));
-                if (placementCount > 0) {
-                    return {
-                        dismissible: false,
-                        severity: "primary",
-                        title: `${placementCount} placements require your attention.`,
-                        message: `Your cohort '${cohorts.name}' has placements for your to review. Click to view these placements.`,
-                        link: `/institutes/cohorts/${cohorts.id}/placements?id=upcoming&reqUserType=${user.userType}`,
-                    };
-                }
-                return;
-            }
-
-            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
-                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", id), where("reqUserType", "==", user.userType)]));
-                if (placementCount > 0) {
-                    return {
-                        dismissible: false,
-                        severity: "primary",
-                        title: `${placementCount} placements in '${cohort.name}' require your attention.`,
-                        message: `Your cohort '${cohort.name}' has placements for your to review. Click to view these placements.`,
-                        link: `/institutes/cohorts/${id}/placements?id=upcoming&reqUserType=${user.userType}`,
-                        buttonTitle: "Review placements",
-                    } as TaskQueryReturnObject;
-                }
-                return;
-            }));
-            return items.filter((v) => v);
-        },
-    },
-    verifyInsurance: {
-        callback: async (user, _, cohorts) => {
-            if (!Array.isArray(cohorts)) {
-                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", cohorts.id), where("insurance", "==", "awaitingReview")]));
-                if (placementCount > 0) {
-                    return {
-                        dismissible: false,
-                        severity: "primary",
-                        title: `${placementCount} placements have insurance that require review.`,
-                        message: `Your cohort '${cohorts.name}' has employer's liability insurance documents that require review`,
-                        link: `/institutes/cohorts/${cohorts.id}/placements`,
-                    };
-                }
-                return;
-            }
-
-            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
-                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", id), where("insurance", "==", "awaitingReview")]));
-                if (placementCount > 0) {
-                    return {
-                        dismissible: false,
-                        severity: "primary",
-                        title: `${placementCount} placements in '${cohort.name}' have insurance that require review.`,
-                        message: `Your cohort '${cohort.name}' has employer's liability insurance documents that require review`,
-                        link: `/institutes/cohorts/${cohort.id}/placements`,
-                        buttonTitle: "Review placements",
-                    } as TaskQueryReturnObject;
-                }
-                return;
-            }));
-            return items.filter((v) => v);
-        },
-    },
-    missingParentEmail: {
-        callback: async (user, _, cohorts) => {
-            if (!Array.isArray(cohorts)) {
-                const constraints = [where("oId", "==", user.oId), where("cohort", "==", cohorts.id), where("details.parentEmail", "==", "null")];
-
-                if (user.groupData?.viewStudents === "filter") {
-                    constraints.push(where(`details.${user.groupData?.filterUsersBy || ""}`, "==", user.groupData?.filterUsersValue || ""));
-                }
-                const studentCount = (await firebaseQuery.getCount(["users"], constraints));
-                if (studentCount > 0) {
-                    return {
-                        dismissible: false,
-                        severity: "info",
-                        title: `${studentCount} students do not have a parent email.`,
-                        message: `Your cohort '${cohorts.name}' has students without a parent email. To allow proper processing of their placements, add these emails.`,
-                        link: `/institutes/cohorts/${cohorts.id}/students`,
-                    };
-                }
-                return;
-            }
-            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
-                const constraints = [where("oId", "==", user.oId), where("cohort", "==", id), where("details.parentEmail", "==", "null")];
-
-                if (user.groupData?.viewStudents === "filter") {
-                    constraints.push(where(`details.${user.groupData?.filterUsersBy || ""}`, "==", user.groupData?.filterUsersValue || ""));
-                }
-                const studentCount = (await firebaseQuery.getCount(["users"], constraints));
-                if (studentCount > 0) {
-                    return {
-                        dismissible: false,
-                        severity: "info",
-                        title: `${studentCount} students in '${cohort.name}' do not have a parent email.`,
-                        message: `Your cohort '${cohort.name}' has students without a parent email. To allow proper processing of their placements, add these emails.`,
-                        link: `/institutes/cohorts/${cohort.id}/students`,
-                        buttonTitle: "View students",
-                    } as TaskQueryReturnObject;
-                }
-                return;
-            }));
-            return items.filter((v) => v);
-        },
-    },
-    inactiveStudents: {
-        callback: async (user, _, cohorts) => {
-            if (!Array.isArray(cohorts)) {
-                const constraints = [where("oId", "==", user.oId), where("cohort", "==", cohorts.id), where("status", "==", "inactive")];
-
-                if (user.groupData?.viewStudents === "filter") {
-                    constraints.push(where(`details.${user.groupData?.filterUsersBy || ""}`, "==", user.groupData?.filterUsersValue || ""));
-                }
-                const studentCount = (await firebaseQuery.getCount(["users"], constraints));
-                if (studentCount > 0) {
-                    return {
-                        dismissible: false,
-                        severity: "info",
-                        title: `${studentCount} students in are inactive.`,
-                        message: `Your cohort '${cohorts.name}' has inactive students. Activate them to enable them to use the platform.`,
-                        link: `/institutes/cohorts/${cohorts.id}/students`,
-                    };
-                }
-                return;
-            }
-
-            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
-                const constraints = [where("oId", "==", user.oId), where("cohort", "==", id), where("status", "==", "inactive")];
-
-                if (user.groupData?.viewStudents === "filter") {
-                    constraints.push(where(`details.${user.groupData?.filterUsersBy || ""}`, "==", user.groupData?.filterUsersValue || ""));
-                }
-                const studentCount = (await firebaseQuery.getCount(["users"], constraints));
-                if (studentCount > 0) {
-                    return {
-                        dismissible: false,
-                        severity: "info",
-                        title: `${studentCount} students in '${cohort.name}' are inactive.`,
-                        message: `Your cohort '${cohort.name}' has inactive students. Activate them to enable them to use the platform.`,
-                        link: `/institutes/cohorts/${cohort.id}/students`,
-                        buttonTitle: "Review placements",
-                    } as TaskQueryReturnObject;
-                }
-                return;
-            }));
-            return items.filter((v) => v);
-        },
-    },
-    inactiveStaff: {
-        callback: async (user, _, cohorts) => {
-            if (!Array.isArray(cohorts) || user.product === "students") return;
-            const returnObj: TaskQueryReturnObject = {
-                link: `/${user.product}/cohorts/staff/all`,
-                dismissible: false,
-                severity: "info",
-            };
-            const inactiveStaff = await firebaseQuery.getCount(["users"], [where("oId", "==", user.oId), where("userType", "==", "Staff"), where("status", "==", "inactive")]);
-            if (inactiveStaff > 0) {
-                return {
-                    ...returnObj,
-                    title: "Inactive staff",
-                    message: `You have ${inactiveStaff} inactive staff members. You can activate them in the 'Staff' cohorts tab.`,
-                };
-            }
-            return;
-        },
-    },
-    overdueStage: {
-        callback: async (user, _, cohort) => {
-            console.log(user, cohort);
-            return undefined;
-        },
-    },
-    approveExternalPlacement: {
-        callback: async (user, _, cohort) => {
-            if (!Array.isArray(cohort)) return;
-            const externalCount = await firebaseQuery.getCount(["placementListings"],
-                [where(`savedBy.${user.oId}.exists`, "==", true), where(`savedBy.${user.oId}.status`, "==", "uploaded"), where("mapConsent", "==", "institute")]);
-            console.log("EXT", externalCount);
-            if (externalCount > 0) {
-                return {
-                    dismissible: false,
-                    severity: "warning",
-                    title: `${externalCount} external placements require approval`,
-                    message: "Review and approve these placements to add them to your institute placement map",
-                    link: "/institutes/placements",
-                    buttonTitle: "View placements",
-                };
-            }
-            return;
-        },
-    },
-};
-
-export const getTipsOrTasks = async (type: "tasks"|"tips", user: UserData, organisation: InstituteData|ProviderData, cohort: CohortData|[string, CohortData][]):Promise<(TaskQueryReturnObject)[]> => {
-    const includedItems = Object.entries(type === "tasks" ? tasks : tips).filter(([k]) => !user.dismissedTips?.includes(k));
-
-    const processedTips = await includedItems.reduce(async (acc, [itemName, item]) => {
-        const queryResult = await item.callback(user, organisation, cohort);
-        if (!queryResult) return await acc;
-
-        const queryResultArray = Array.isArray(queryResult) ? queryResult : [queryResult];
-        const results = queryResultArray.map((r) => ({itemName: itemName as TipNames|TaskNames, ...r}));
-
-        (await acc).push(...results);
-        return await acc;
-    }, Promise.resolve<TaskQueryReturnObject[]>([]));
-    return processedTips;
-};
-/*
-export const getTasks = async (user: UserData):Promise<{[key:string]: TaskQueryReturnObject}> => {
-    return Object.fromEntries((await Promise.all(Object.entries(tasks).filter(([k]) => !user.dismissedTasks?.includes(k)).map(async ([taskName, task]) => {
-        const queryResult = await task.callback(user);
-        return [taskName, queryResult ? {...queryResult, ...task} : undefined];
-    }))).filter(([, v]) => v));
-};
-
-export const dismissTask = (user: UserData, taskName:TaskNames) => {
-    firebaseQuery.update(["users", user.id], {dismissedTasks: arrayUnion(taskName)});
-};
-*/
-export const dismissTip = async (user: UserData, itemName:TaskNames | TipNames | undefined) => {
-    if (!itemName) return;
-    return await firebaseQuery.update(["users", user.id], {dismissedTips: arrayUnion(itemName)});
-};
+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 { convertDate } from "./firebase/util";
+
+const firebaseQuery = new FirebaseQuery;
+
+type InstituteTipNames = "createCohort"|"uploadStaff"|"assignStaffRoles"|"uploadPlacements"|"allowExternalPlacementUpload"|"uploadStaffGuidance"|"uploadStudentGuidance"
+type ProviderTipNames = string
+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"
+
+// IF UPDATING LOGIC WITHIN THIS FILE, PLACEMENTT-BACKEND LOGIC MUST ALSO BE CHANGED ACCORDINGLY
+
+export type TaskQueryReturnObject = {
+    itemName?: InstituteTaskNames|InstituteTipNames|StudentTipNames|ProviderTipNames,
+    title?: string,
+    message?: string,
+    link?: string,
+    buttonTitle?: string,
+    dismissible?: boolean,
+    severity?: "error"|"warning"|"success"|"primary"|"info"
+}|undefined;
+/*
+type TasksObject = {
+    [key in TaskNames]: {
+        callback: (user: UserData) => Promise<TaskQueryReturnObject>,
+    };
+};
+*/
+type InstituteTipsObject = {
+    [key in InstituteTipNames]: {
+        callback: (user: UserData, organisation?:InstituteData|ProviderData) => Promise<TaskQueryReturnObject|TaskQueryReturnObject[]>,
+    };
+};
+type ProviderTipsObject = {
+    [key in ProviderTipNames]: {
+        callback: (user: UserData, organisation?:InstituteData|ProviderData) => Promise<TaskQueryReturnObject|TaskQueryReturnObject[]>,
+    };
+};
+type StudentTipsObject = {
+    [key in StudentTipNames]: {
+        callback: (user: UserData, organisation?:InstituteData|ProviderData) => Promise<TaskQueryReturnObject|TaskQueryReturnObject[]>,
+    };
+};
+
+export type InstituteTaskObject = {
+    [key in InstituteTaskNames]: {
+        callback: (user: UserData, organisation:InstituteData|ProviderData, cohort: CohortData|[string, CohortData][]) => Promise<TaskQueryReturnObject|TaskQueryReturnObject[]>,
+    };
+};
+
+export type StudentTaskObject = {
+    [key in StudentTaskNames]: {
+        callback: (user: UserData) => Promise<TaskQueryReturnObject|TaskQueryReturnObject[]>,
+    };
+};
+export type ProviderTaskObject = {
+    [key in ProviderTaskNames]: {
+        callback: (user: UserData) => Promise<TaskQueryReturnObject|TaskQueryReturnObject[]>,
+    };
+};
+const providerTips:ProviderTipsObject = {}
+const studentTips:StudentTipsObject = {}
+
+
+const instituteTips:InstituteTipsObject = {
+    createCohort: {
+        callback: async (user) => {
+            if (!getAccess(user, "createCohorts")) return;
+            const cohorts = await firebaseQuery.getCount("cohorts", [where("product", "==", user.product), where("oId", "==", user.oId)])
+            if (cohorts === 0) {
+                return {
+                    title: "Create a cohort",
+                    message: "Create a cohort to manage your students, process their placements and track their progress",
+                    link: "/institutes/cohorts/new",
+                    buttonTitle: "Create cohort",
+                };
+            }
+            return;
+        },
+    },
+    uploadStaff: {
+        callback: async (user) => {
+            const returnObj: TaskQueryReturnObject = {
+                link: "",
+                dismissible: true,
+            };
+            if ((await firebaseQuery.getCount(["users"], [where("oId", "==", user.oId), where("userType", "==", "Staff")])) == 1) {
+                return {
+                    ...returnObj,
+                    title: "Upload staff",
+                    message: "Upload staff to help manage your students",
+                    link: "/institutes/cohorts/staff/all",
+                    buttonTitle: "Upload staff",
+                };
+            }
+            return;
+        },
+    },
+    assignStaffRoles: {
+        callback: async () => {
+            return undefined;
+        },
+    },
+    uploadPlacements: {
+        callback: async (user) => {
+            const returnObj: TaskQueryReturnObject = {
+                link: "",
+                dismissible: true,
+            };
+            if (await firebaseQuery.getCount(["placementListings"], where(`savedBy.${user.oId}.exists`, "==", true)) === 0) {
+                return {
+                    ...returnObj,
+                    title: "List placements",
+                    message: "You can list placements to students, to give them places to contact. Check out the 'Placements' tab to list opportunitites.",
+                    link: "/institutes/placements",
+                    buttonTitle: "Add placements",
+                };
+            }
+            return;
+        },
+    },
+    allowExternalPlacementUpload: {
+        callback: async (user, organisation) => {
+            if (user.product !== "institutes") return;
+            if ((organisation as InstituteData).externalProviderUploads) return;
+
+            return {
+                dismissible: true,
+                title: "Allow external uploads",
+                message: "Get a link to share with businesses, allowing them to list their own opportunities to your students.",
+                link: "/institutes/placements",
+                buttonTitle: "View placements",
+            };
+        },
+    },
+    uploadStaffGuidance: {
+        callback: async (user, organisation) => {
+            if (user.product !== "institutes") return;
+            const returnObj: TaskQueryReturnObject = {
+                link: "",
+                dismissible: true,
+            };
+            const guidanceTips:TaskQueryReturnObject[] = [];
+            if (!Object.keys((organisation as InstituteData).staffGuidance || {}).length) {
+                guidanceTips.push({
+                    ...returnObj,
+                    title: "Upload staff guidance",
+                    message: "Upload guidance documents to support your staff in coordinating work experience.",
+                    buttonTitle: "Staff guidance",
+                    link: `/${user.product}/setup/guidance`,
+                });
+            }
+            return guidanceTips;
+        },
+    },
+    uploadStudentGuidance: {
+        callback: async (user, organisation) => {
+            if (user.product !== "institutes") return;
+            const returnObj: TaskQueryReturnObject = {
+                link: "",
+                dismissible: true,
+            };
+            const guidanceTips:TaskQueryReturnObject[] = [];
+            if (!Object.keys((organisation as InstituteData).studentsGuidance || {}).length) {
+                guidanceTips.push({
+                    ...returnObj,
+                    title: "Upload student guidance",
+                    message: "Upload guidance documents to support your staff in preparing for their placements.",
+                    buttonTitle: "Student guidance",
+                    link: `/${user.product}/setup/guidance`,
+                });
+            }
+            return guidanceTips;
+        },
+    },
+};
+//  Accept a cohort to any task
+
+const instituteTasks:InstituteTaskObject = {
+    requiredStage: {
+        callback: async (user, _, cohorts) => {
+            if (!getAccess(user, "signOffPlacements")) return;
+
+            if (!Array.isArray(cohorts)) {
+                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", cohorts.id), where("reqUserType", "==", user.userType)]));
+                if (placementCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "primary",
+                        title: `${placementCount} placements require your attention.`,
+                        message: `Your cohort '${cohorts.name}' has placements for your to review. Click to view these placements.`,
+                        link: `/institutes/cohorts/${cohorts.id}/placements?id=upcoming&reqUserType=${user.userType}`,
+                    };
+                }
+                return;
+            }
+
+            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
+                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", id), where("reqUserType", "==", user.userType)]));
+                if (placementCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "primary",
+                        title: `${placementCount} placements in '${cohort.name}' require your attention.`,
+                        message: `Your cohort '${cohort.name}' has placements for your to review. Click to view these placements.`,
+                        link: `/institutes/cohorts/${id}/placements?id=upcoming&reqUserType=${user.userType}`,
+                        buttonTitle: "Review placements",
+                    } as TaskQueryReturnObject;
+                }
+                return;
+            }));
+            return items.filter((v) => v);
+        },
+    },
+    verifyInsurance: {
+        callback: async (user, _, cohorts) => {
+            if (!getAccess(user, "verifyInsurance")) return;
+
+            if (!Array.isArray(cohorts)) {
+                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", cohorts.id), where("insurance", "==", "awaitingReview")]));
+                if (placementCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "primary",
+                        title: `${placementCount} placements have insurance that require review.`,
+                        message: `Your cohort '${cohorts.name}' has employer's liability insurance documents that require review`,
+                        link: `/institutes/cohorts/${cohorts.id}/placements?id=upcoming&insurance=awaitingReview`,
+                    };
+                }
+                return;
+            }
+
+            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
+                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", id), where("insurance", "==", "awaitingReview")]));
+                if (placementCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "primary",
+                        title: `${placementCount} placements in '${cohort.name}' have insurance that require review.`,
+                        message: `Your cohort '${cohort.name}' has employer's liability insurance documents that require review`,
+                        link: `/institutes/cohorts/${cohort.id}/placements?id=upcoming&insurance=awaitingReview`,
+                        buttonTitle: "Review placements",
+                    } as TaskQueryReturnObject;
+                }
+                return;
+            }));
+            return items.filter((v) => v);
+        },
+    },
+    verifyDbsCheck: {
+        callback: async (user, _, cohorts) => {
+            if (!getAccess(user, "verifyDbsChecks")) return;
+
+            if (!Array.isArray(cohorts)) {
+                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", cohorts.id), where("dbsCheck", "==", "awaitingReview")]));
+                if (placementCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "primary",
+                        title: `${placementCount} placements have DBS checks that require review.`,
+                        message: `Your cohort '${cohorts.name}' has DBS checks that require review`,
+                        link: `/institutes/cohorts/${cohorts.id}/placements?id=upcoming&dbsCheck=awaitingReview`,
+                    };
+                }
+                return;
+            }
+
+            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
+                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", id), where("dbsCheck", "==", "awaitingReview")]));
+                if (placementCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "primary",
+                        title: `${placementCount} placements in '${cohort.name}' have DBS checks that require review.`,
+                        message: `Your cohort '${cohort.name}' has DBS checks that require review`,
+                        link: `/institutes/cohorts/${cohort.id}/placements?id=upcoming&dbsCheck=awaitingReview`,
+                        buttonTitle: "Review placements",
+                    } as TaskQueryReturnObject;
+                }
+                return;
+            }));
+            return items.filter((v) => v);
+        },
+    },
+    verifyRiskAssessment: {
+        callback: async (user, _, cohorts) => {
+            if (!getAccess(user, "verifyRiskAssessments")) return;
+
+            if (!Array.isArray(cohorts)) {
+                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", cohorts.id), where("riskAssessment", "==", "awaitingReview")]));
+                if (placementCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "primary",
+                        title: `${placementCount} placements have risk assessments that require review.`,
+                        message: `Your cohort '${cohorts.name}' has risk assessents that require review`,
+                        link: `/institutes/cohorts/${cohorts.id}/placements?id=upcoming&riskAssessment=awaitingReview`,
+                    };
+                }
+                return;
+            }
+
+            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
+                const placementCount = (await firebaseQuery.getCount(["placements"], [where("oId", "==", user.oId), where("cohort", "==", id), where("riskAssessment", "==", "awaitingReview")]));
+                if (placementCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "primary",
+                        title: `${placementCount} placements in '${cohort.name}' have risk assessments that require review.`,
+                        message: `Your cohort '${cohort.name}' has risk assessments that require review`,
+                        link: `/institutes/cohorts/${cohort.id}/placements?id=upcoming&riskAssessment=awaitingReview`,
+                        buttonTitle: "Review placements",
+                    } as TaskQueryReturnObject;
+                }
+                return;
+            }));
+            return items.filter((v) => v);
+        },
+    },
+    missingParentEmail: {
+        callback: async (user, _, cohorts) => {
+            if (!getAccess(user, "editStudents")) return;
+            if (!Array.isArray(cohorts)) {
+                const requiresParents = Boolean(cohorts.workflow.find((node) => node.userType === "Parent"))
+                if (!requiresParents) return;
+                const constraints = [where("oId", "==", user.oId), where("cohort", "==", cohorts.id), where("details.parentEmail", "==", "null")];
+
+                if (user.groupData?.viewStudents === "filter") {
+                    constraints.push(where(`details.${user.groupData?.filterUsersBy || ""}`, "==", user.groupData?.filterUsersValue || ""));
+                }
+                const studentCount = (await firebaseQuery.getCount(["users"], constraints));
+                if (studentCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "info",
+                        title: `${studentCount} students do not have a parent email.`,
+                        message: `Your cohort '${cohorts.name}' has students without a parent email. To allow proper processing of their placements, add these emails.`,
+                        link: `/institutes/cohorts/${cohorts.id}/students?parentEmail=false`,
+                    };
+                }
+                return;
+            }
+            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
+                const requiresParents = Boolean(cohort.workflow.find((node) => node.userType === "Parent"))
+                if (!requiresParents) return;
+                const constraints = [where("oId", "==", user.oId), where("cohort", "==", id), where("details.parentEmail", "==", "null")];
+
+                if (user.groupData?.viewStudents === "filter") {
+                    constraints.push(where(`details.${user.groupData?.filterUsersBy || ""}`, "==", user.groupData?.filterUsersValue || ""));
+                }
+                const studentCount = (await firebaseQuery.getCount(["users"], constraints));
+                if (studentCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "info",
+                        title: `${studentCount} students in '${cohort.name}' do not have a parent email.`,
+                        message: `Your cohort '${cohort.name}' has students without a parent email. To allow proper processing of their placements, add these emails.`,
+                        link: `/institutes/cohorts/${cohort.id}/students?parentEmail=false`,
+                        buttonTitle: "View students",
+                    } as TaskQueryReturnObject;
+                }
+                return;
+            }));
+            return items.filter((v) => v);
+        },
+    },
+    inactiveStudents: {
+        callback: async (user, _, cohorts) => {
+            if (!getAccess(user, "activateStudents")) return;
+            if (!Array.isArray(cohorts)) {
+                const constraints = [where("oId", "==", user.oId), where("cohort", "==", cohorts.id), where("status", "==", "inactive")];
+
+                if (user.groupData?.viewStudents === "filter") {
+                    constraints.push(where(`details.${user.groupData?.filterUsersBy || ""}`, "==", user.groupData?.filterUsersValue || ""));
+                }
+                const studentCount = (await firebaseQuery.getCount(["users"], constraints));
+                if (studentCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "info",
+                        title: `${studentCount} students in are inactive.`,
+                        message: `Your cohort '${cohorts.name}' has inactive students. Activate them to enable them to use the platform.`,
+                        link: `/institutes/cohorts/${cohorts.id}/students?status=inactive`,
+                    };
+                }
+                return;
+            }
+
+            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
+                const constraints = [where("oId", "==", user.oId), where("cohort", "==", id), where("status", "==", "inactive")];
+
+                if (user.groupData?.viewStudents === "filter") {
+                    constraints.push(where(`details.${user.groupData?.filterUsersBy || ""}`, "==", user.groupData?.filterUsersValue || ""));
+                }
+                const studentCount = (await firebaseQuery.getCount(["users"], constraints));
+                if (studentCount > 0) {
+                    return {
+                        dismissible: false,
+                        severity: "info",
+                        title: `${studentCount} students in '${cohort.name}' are inactive.`,
+                        message: `Your cohort '${cohort.name}' has inactive students. Activate them to enable them to use the platform.`,
+                        link: `/institutes/cohorts/${cohort.id}/students?status=inactive`,
+                        buttonTitle: "Review placements",
+                    } as TaskQueryReturnObject;
+                }
+                return;
+            }));
+            return items.filter((v) => v);
+        },
+    },
+    uploadStudents: {
+        callback: async (user, _, cohorts) => {
+            if (!Array.isArray(cohorts)) return;
+            if (!getAccess(user, "addStudents")) return;
+            if (user.product !== "institutes") return;
+            const returnObj: TaskQueryReturnObject = {
+                link: "",
+                dismissible: true,
+                severity: "warning",
+            };
+            const items = await Promise.all(cohorts.map(async ([id, cohort]) => {
+                const studentCount = (await firebaseQuery.getCount(["users"], [where("oId", "==", user.oId), where("userType", "==", "Students"), where("cohort", "==", id)]));
+                if (studentCount === 0) {
+                    return {
+                        ...returnObj,
+                        title: "Upload students",
+                        message: `Your cohort '${cohort.name}' has no students. Add them in the cohort 'Students' tab`,
+                        link: `/institutes/cohorts/${id}/students`,
+                        buttonTitle: "Upload students",
+                    };
+                }
+                return;
+            }));
+            return items.filter((v) => v);
+        },
+    },
+    inactiveStaff: {
+        callback: async (user, _, cohorts) => {
+            if (!getAccess(user, "addStaff")) return;
+
+            if (!Array.isArray(cohorts) || user.product === "students") return;
+            const returnObj: TaskQueryReturnObject = {
+                link: `/${user.product}/cohorts/staff/all?status=inactive`,
+                dismissible: false,
+                severity: "info",
+            };
+            const inactiveStaff = await firebaseQuery.getCount(["users"], [where("oId", "==", user.oId), where("userType", "==", "Staff"), where("status", "==", "inactive")]);
+            if (inactiveStaff > 0) {
+                return {
+                    ...returnObj,
+                    title: "Inactive staff",
+                    message: `You have ${inactiveStaff} inactive staff members. You can activate them in the 'Staff' cohorts tab.`,
+                };
+            }
+            return;
+        },
+    },
+    overdueStage: {
+        callback: async (user, _, cohort) => {
+            console.log(user, cohort);
+            return undefined;
+        },
+    },
+    approveExternalPlacement: {
+        callback: async (user, _, cohort) => {
+            if (!getAccess(user, "verifyListings")) return;
+            if (!Array.isArray(cohort)) return;
+            const externalCount = await firebaseQuery.getCount(["placementListings"],
+                [where(`savedBy.${user.oId}.exists`, "==", true), where(`savedBy.${user.oId}.status`, "==", "uploaded"), where("mapConsent", "==", "institute")]);
+            console.log("EXT", externalCount);
+            if (externalCount > 0) {
+                return {
+                    dismissible: false,
+                    severity: "warning",
+                    title: `${externalCount} external placements require approval`,
+                    message: "Review and approve these placements to add them to your institute placement map",
+                    link: "/institutes/placements",
+                    buttonTitle: "View placements",
+                };
+            }
+            return;
+        },
+    },
+};
+
+const studentTasks:StudentTaskObject = {
+    completeOnboarding: {
+        callback: async (user) => {
+            const placementsWithoutOnboarding = await firebaseQuery.getDocsWhere("placements", [where("uid", "==", user.id), where("onboarding.deadline", "<=", convertDate(new Date(), "dbstring")), where("onboarding.completed.submitted", "==", false)]) as {[key: string]: StudentPlacementData};
+            console.log("placementsWithoutONboarding", placementsWithoutOnboarding);
+            if (Object.keys(placementsWithoutOnboarding).length === 0) return;
+            const items = Object.entries(placementsWithoutOnboarding).map(([k, placement]) => ({
+                dismissible: false,
+                severity: "primary",
+                title: `Complete required onboarding documents for ${placement.name}`,
+                message: `${placement.name} has requested you to complete some onboarding documents.`,
+                link: `/${user.product}/placements/${k}`,
+                buttonTitle: "View onboarding",
+            } as TaskQueryReturnObject))
+            return items;
+        },
+    }
+}
+
+const providerTasks:ProviderTaskObject = {
+    requestedVisibleAddresses: {
+        callback: async (user) => {
+            const accessRequests = await firebaseQuery.getCount("users", [where("oId", "==", user.oId), where("product", "==", "providers"), orderBy("requestedVisibleAddresses")]);
+            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];
+                return {
+                    dismissible: false,
+                    severity: "primary",
+                    title: `${userRequestingAccess[1].details.forename} ${userRequestingAccess[1].details.surname} has requested access to view addresses.`,
+                    message: `Click to review the addresses and grant access to the user.`,
+                    link: `/${user.product}/users/${userRequestingAccess[0]}`,
+                    buttonTitle: "View request",
+                } as TaskQueryReturnObject;
+        }
+
+            return {
+                dismissible: false,
+                severity: "warning",
+                title: `Multiple users have requested access to view addresses.`,
+                message: `Click to review the addresses and grant access to the user.`,
+                link: `/${user.product}/organisation/staff/all`,
+                buttonTitle: "View request",
+            } as TaskQueryReturnObject;
+        },
+    },
+    requestedVisiblePlacementListings: {
+        callback: async (user) => {
+            const accessRequests = await firebaseQuery.getCount("users", [where("oId", "==", user.oId), where("product", "==", "providers"), orderBy("requestedVisibleListings")]);
+            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];
+                return {
+                    dismissible: false,
+                    severity: "primary",
+                    title: `${userRequestingAccess[1].details.forename} ${userRequestingAccess[1].details.surname} has requested access to view placement listings.`,
+                    message: `Click to review the placement listings and grant access to the user.`,
+                    link: `/${user.product}/users/${userRequestingAccess[0]}`,
+                    buttonTitle: "View request",
+                } as TaskQueryReturnObject;
+        }
+
+            return {
+                dismissible: false,
+                severity: "warning",
+                title: `Multiple users have requested access to view placement listings.`,
+                message: `Click to review the placement listings and grant access to the user.`,
+                link: `/${user.product}/organisation/staff/all`,
+                buttonTitle: "View request",
+            } as TaskQueryReturnObject;
+        },
+    },
+    applicationRequireReview: {
+        callback: async (user) => {
+            const applicationCount = await firebaseQuery.getCount("applications", [where("providerId", "==", user.oId), where("reqUserType", "==", "Staff"), where("status", "==", "submitted")]);
+            if (applicationCount === 0) return;
+
+            return {
+                dismissible: false,
+                severity: "primary",
+                title: `${applicationCount} applications require your review.`,
+                message: `Click to view ${applicationCount} that require your attention.`,
+                link: `/${user.product}/placementListings/applicants`,
+                buttonTitle: "View applications",
+            } as TaskQueryReturnObject;
+        },
+    },
+    completeStudentDocs: {
+        callback: async (user) => {
+            return {} as TaskQueryReturnObject;
+        },
+    },
+    reviewOnboarding: {
+        callback: async (user) => {
+            return {} as TaskQueryReturnObject;
+        },
+    },
+    completeListing: {
+        callback: async (user) => {
+            return {} as TaskQueryReturnObject;
+        },
+    },
+    completeAddress: {
+        callback: async (user) => {
+            return {} as TaskQueryReturnObject;
+        },
+    },
+    registrationRequests: {
+        callback: async (user) => {
+            return {} as TaskQueryReturnObject;
+        },
+    },
+    placementStarting: {
+        callback: async (user) => {
+            return {} as TaskQueryReturnObject;
+        },
+    },
+    completeFeedback: {
+        callback: async (user) => {
+            return {} as TaskQueryReturnObject;
+        },
+    },
+    setUpFeedback: {
+        callback: async (user) => {
+            return {} as TaskQueryReturnObject;
+        },
+    },
+}
+
+export const getTips = async (user: UserData, organisation: InstituteData|ProviderData):Promise<(TaskQueryReturnObject)[]> => {
+    const tipsObject = {
+        providers: providerTips,
+        institutes: instituteTips,
+        studentTips: studentTips,
+    }
+    const includedItems = Object.entries(tipsObject[user.product]).filter(([k]) => !user.dismissedTips?.includes(k));
+
+    const processedTips = await includedItems.reduce(async (acc, [itemName, item]) => {
+        const queryResult = await (item as {
+            callback: (user: UserData, organisation?:InstituteData|ProviderData) => Promise<TaskQueryReturnObject|TaskQueryReturnObject[]>,
+        }).callback(user, organisation);
+        if (!queryResult) return await acc;
+
+        const queryResultArray = Array.isArray(queryResult) ? queryResult : [queryResult];
+        const results = queryResultArray.map((r) => ({itemName: itemName as InstituteTipNames|ProviderTipNames|StudentTipNames|InstituteTaskNames|ProviderTaskNames|StudentTaskNames, ...r}));
+
+        (await acc).push(...results);
+        return await acc;
+    }, Promise.resolve<TaskQueryReturnObject[]>([]));
+    return processedTips;
+}
+
+export const getTasks = async (user: UserData, organisation?: InstituteData|ProviderData, cohort?: CohortData):Promise<(TaskQueryReturnObject)[]> => {
+    // Cohort is either a specific one or all.
+
+    if (user.product === "institutes" && user.userType === "Staff" && organisation) {
+        return await getInstituteTasks(user, organisation, cohort);
+    }
+    if (user.product === "students" || user.userType === "Students") {
+        return await getStudentTasks(user, organisation, cohort);
+    }
+    if (user.product === "providers" && organisation) {
+        return await getProviderTasks(user, organisation);
+    }
+
+    return [];
+};
+
+const getStudentTasks = async (user: UserData, organisation?: InstituteData|ProviderData, cohort?: CohortData):Promise<(TaskQueryReturnObject)[]> => {
+    const processedTasks = await Object.entries(studentTasks).reduce(async (acc, [itemName, item]) => {
+
+        const queryResult = await item.callback(user);
+        if (!queryResult) return await acc;
+
+        const queryResultArray = Array.isArray(queryResult) ? queryResult : [queryResult];
+        const results = queryResultArray.map((r) => ({itemName: itemName as StudentTaskNames, ...r}));
+
+        (await acc).push(...results);
+        return await acc;
+    }, Promise.resolve<TaskQueryReturnObject[]>([]));
+    return processedTasks;
+};
+
+const getProviderTasks = async (user: UserData, organisation: InstituteData|ProviderData, cohort?: CohortData):Promise<(TaskQueryReturnObject)[]> => {
+    const processedTasks = await Object.entries(providerTasks).reduce(async (acc, [itemName, item]) => {
+
+        const queryResult = await item.callback(user);
+        if (!queryResult) return await acc;
+
+        const queryResultArray = Array.isArray(queryResult) ? queryResult : [queryResult];
+        const results = queryResultArray.map((r) => ({itemName: itemName as ProviderTaskNames, ...r}));
+
+        (await acc).push(...results);
+        return await acc;
+    }, Promise.resolve<TaskQueryReturnObject[]>([]));
+    return processedTasks;};
+
+const getInstituteTasks = async (user: UserData, organisation: InstituteData|ProviderData, cohort?: CohortData):Promise<(TaskQueryReturnObject)[]> => {
+    let fCohort:CohortData|[string, CohortData][]|undefined = cohort;
+
+    if (!fCohort) {
+        // get all associated cohorts.
+        if (user.viewCohorts === "none") return([]);
+        if (user.userGroup === "admin" || user.viewCohorts === "all") {
+            const cohorts = await firebaseQuery.getDocsWhere("cohorts", [where("product", "==", user.product), where("oId", "==", user.oId), where("stage", "==", "created")]) as {[key:string]: CohortData};
+            fCohort = Object.entries(cohorts);
+        }
+        if (user.viewCohorts === "some") {
+            const cohorts = await user.visibleCohorts?.split(",").reduce(async (acc, cohortId) => {
+                const cohort = await firebaseQuery.getDocData(["cohorts", cohortId]) as CohortData;
+                if (cohort.stage !== "created") {
+                    return acc;
+                }
+                acc[cohortId] = cohort;
+                return acc;
+            }, Promise.resolve<[string, CohortData][]>([]));
+            fCohort = cohorts;
+        }
+    }
+    
+    const processedTasks = await Object.entries(instituteTasks).reduce(async (acc, [itemName, item]) => {
+        if (!fCohort) {
+            console.log("No cohorts to retrieve tasks for");
+            return([]);
+        }
+        const queryResult = await item.callback(user, organisation, fCohort);
+        if (!queryResult) return await acc;
+
+        const queryResultArray = Array.isArray(queryResult) ? queryResult : [queryResult];
+        const results = queryResultArray.map((r) => ({itemName: itemName as InstituteTaskNames, ...r}));
+
+        (await acc).push(...results);
+        return await acc;
+    }, Promise.resolve<TaskQueryReturnObject[]>([]));
+    return processedTasks;
+}
+
+/*
+export const getTasks = async (user: UserData):Promise<{[key:string]: TaskQueryReturnObject}> => {
+    return Object.fromEntries((await Promise.all(Object.entries(tasks).filter(([k]) => !user.dismissedTasks?.includes(k)).map(async ([taskName, task]) => {
+        const queryResult = await task.callback(user);
+        return [taskName, queryResult ? {...queryResult, ...task} : undefined];
+    }))).filter(([, v]) => v));
+};
+
+export const dismissTask = (user: UserData, taskName:TaskNames) => {
+    firebaseQuery.update(["users", user.id], {dismissedTasks: arrayUnion(taskName)});
+};
+*/
+export const dismissTip = async (user: UserData, itemName:InstituteTaskNames | ProviderTaskNames | StudentTaskNames | InstituteTipNames | ProviderTipNames | StudentTipNames | undefined) => {
+    if (!itemName) return;
+    return await firebaseQuery.update(["users", user.id], {dismissedTips: arrayUnion(itemName)});
+};