ENCOA-217: Adapted the invite system to now work based on Entities instead of Users/Groups

src/components/Medium/InviteWithUserCard.tsx

@@ -1,4 +1,4 @@
-import {Invite, InviteWithUsers} from "@/interfaces/invite";
+import {Invite, InviteWithEntity} from "@/interfaces/invite";
 import {User} from "@/interfaces/user";
 import {getUserName} from "@/utils/users";
 import axios from "axios";
@@ -7,14 +7,14 @@ import {BsArrowRepeat} from "react-icons/bs";
 import {toast} from "react-toastify";
 
 interface Props {
-	invite: InviteWithUsers;
+	invite: InviteWithEntity;
 	reload: () => void;
 }
 
 export default function InviteWithUserCard({invite, reload}: Props) {
 	const [isLoading, setIsLoading] = useState(false);
 
-	const name = useMemo(() => (!invite.from ? null : getUserName(invite.from)), [invite.from]);
+	const name = useMemo(() => (!invite.entity ? null : invite.entity.label), [invite.entity]);
 
 	const decide = (decision: "accept" | "decline") => {
 		if (!confirm(`Are you sure you want to ${decision} this invite?`)) return;
@@ -37,7 +37,7 @@ export default function InviteWithUserCard({invite, reload}: Props) {
 
 	return (
 		<div className="border-mti-gray-anti-flash flex min-w-[200px] flex-col gap-6 rounded-xl border p-4 text-black">
-			<span>Invited by {name}</span>
+			<span>Invited to <b>{name}</b></span>
 			<div className="flex items-center gap-2">
 				<button
 					onClick={() => decide("accept")}

src/email/templates/receivedInvite.handlebars

@@ -13,7 +13,7 @@
     <span>Hello {{name}},</span>
     <br/>
     <br/>
-    <span>You have been invited to join {{corporateName}}'s group!</span>
+    <span>You have been invited to join the {{entity}} entity!</span>
     <br />
     <br/>
     <span>Please access the platform to accept or decline the invite.</span>

src/interfaces/invite.ts

@@ -1,11 +1,12 @@
-import {User} from "./user";
+import { Entity } from "./entity";
 
 export interface Invite {
 	id: string;
-	from: string;
+	entity: string;
+	from: string
 	to: string;
 }
 
-export interface InviteWithUsers extends Omit<Invite, "from"> {
+export interface InviteWithEntity extends Omit<Invite, "entity"> {
-	from?: User;
+	entity?: Entity;
 }

src/pages/(admin)/BatchCreateUser.tsx

@@ -161,23 +161,42 @@ export default function BatchCreateUser({user, users, entities = [], permissions
 
 	const makeUsers = async () => {
 		const newUsers = infos.filter((x) => !users.map((u) => u.email).includes(x.email));
-		if (!confirm(`You are about to add ${newUsers.length}, are you sure you want to continue?`)) return;
+		const existingUsers = infos
+			.filter((x) => users.map((u) => u.email).includes(x.email))
+			.map((i) => users.find((u) => u.email === i.email))
+			.filter((x) => !!x && x.type === "student") as User[];
+
+		const newUsersSentence = newUsers.length > 0 ? `create ${newUsers.length} user(s)` : undefined;
+		const existingUsersSentence = existingUsers.length > 0 ? `invite ${existingUsers.length} registered student(s)` : undefined;
+
+		if (!confirm(`You are about to ${[newUsersSentence, existingUsersSentence].filter((x) => !!x).join(" and ")}, are you sure you want to continue?`))
+			return;
+
+		Promise.all(existingUsers.map(async (u) => await axios.post(`/api/invites`, {to: u.id, entity, from: user.id})))
+			.then(() => toast.success(`Successfully invited ${existingUsers.length} registered student(s)!`))
+			.finally(() => {
+				if (newUsers.length === 0) setIsLoading(false);
+			});
 
 		if (newUsers.length > 0) {
 			setIsLoading(true);
 
 			try {
-				const result = await axios.post("/api/batch_users", {users: newUsers.map((user) => ({...user, type, expiryDate}))});
+				await axios.post("/api/batch_users", {users: newUsers.map((user) => ({...user, type, expiryDate}))});
-				console.log(result)
 				toast.success(`Successfully added ${newUsers.length} user(s)!`);
 				onFinish();
-			} catch {
+			} catch(e) {
+				console.error(e)
 				toast.error("Something went wrong, please try again later!");
 			} finally {
 				setIsLoading(false);
 				setInfos([]);
 				clear();
 			}
+		} else {
+			setIsLoading(false);
+			setInfos([]);
+			clear();
 		}
 	};
 

src/pages/api/hello.ts

@@ -9,7 +9,8 @@ type Data = {
 };
 
 export default async function handler(req: NextApiRequest, res: NextApiResponse<Data>) {
-	await db.collection("users").updateMany({}, {$set: {entities: []}});
+	// await db.collection("users").updateMany({}, {$set: {entities: []}});
+	await db.collection("invites").deleteMany({});
 
 	res.status(200).json({name: "John Doe"});
 }

src/pages/api/invites/accept/[id].ts

@@ -8,6 +8,8 @@ import { CorporateUser, Group, User } from "@/interfaces/user";
 import { v4 } from "uuid";
 import { sendEmail } from "@/email";
 import { updateExpiryDateOnGroup } from "@/utils/groups.be";
+import { addUserToEntity, getEntity, getEntityWithRoles } from "@/utils/entities.be";
+import { findBy } from "@/utils";
 
 const db = client.db(process.env.MONGODB_DB);
 
@@ -19,72 +21,6 @@ async function handler(req: NextApiRequest, res: NextApiResponse) {
 	res.status(404).json(undefined);
 }
 
-async function addToInviterGroup(user: User, invitedBy: User) {
-	const invitedByGroups = await db.collection("groups").find<Group>({ admin: invitedBy.id }).toArray();
-	const typeGroupName = user.type === "student" ? "Students" : user.type === "teacher" ? "Teachers" : undefined;
-
-	if (typeGroupName) {
-		const typeGroup: Group = invitedByGroups.find((g) => g.name === typeGroupName) || {
-			id: v4(),
-			admin: invitedBy.id,
-			name: typeGroupName,
-			participants: [],
-			disableEditing: true,
-		};
-
-		await db.collection("groups").updateOne(
-			{ id: typeGroup.id },
-			{
-				$set: {
-					...typeGroup,
-					participants: [...typeGroup.participants.filter((x) => x !== user.id), user.id],
-				},
-			},
-			{ upsert: true }
-		);
-
-	}
-
-	const invitationsGroup: Group = invitedByGroups.find((g) => g.name === "Invited") || {
-		id: v4(),
-		admin: invitedBy.id,
-		name: "Invited",
-		participants: [],
-		disableEditing: true,
-	};
-
-	await db.collection("groups").updateOne(
-		{ id: invitationsGroup.id },
-		{
-			$set: {
-				...invitationsGroup,
-				participants: [...invitationsGroup.participants.filter((x) => x !== user.id), user.id],
-			}
-		},
-		{ upsert: true }
-	);
-}
-
-async function deleteFromPreviousCorporateGroups(user: User, invitedBy: User) {
-	const corporatesRef = await db.collection("users").find<CorporateUser>({ type: "corporate" }).toArray();
-	const corporates = corporatesRef.filter((x) => x.id !== invitedBy.id);
-
-	const userGroups = await db.collection("groups").find<Group>({
-		participants: user.id
-	}).toArray();
-
-	const corporateGroups = userGroups.filter((x) => corporates.map((c) => c.id).includes(x.admin));
-	await Promise.all(
-		corporateGroups.map(async (group) => {
-			await db.collection("groups").updateOne(
-				{ id: group.id },
-				{ $set: { participants: group.participants.filter((x) => x !== user.id) } },
-				{ upsert: true }
-			);
-		}),
-	);
-}
-
 async function get(req: NextApiRequest, res: NextApiResponse) {
 	if (!req.session.user) {
 		res.status(401).json({ ok: false });
@@ -102,10 +38,11 @@ async function get(req: NextApiRequest, res: NextApiResponse) {
 		const invitedBy = await db.collection("users").findOne<User>({ id: invite.from});
 		if (!invitedBy) return res.status(404).json({ ok: false });
 
-		await updateExpiryDateOnGroup(invite.to, invite.from);
+		const inviteEntity = await getEntityWithRoles(invite.entity)
+		if (!inviteEntity) return res.status(404).json({ ok: false });
 
-		if (invitedBy.type === "corporate") await deleteFromPreviousCorporateGroups(req.session.user, invitedBy);
+		const defaultRole = findBy(inviteEntity.roles, 'isDefault', true)!
-		await addToInviterGroup(req.session.user, invitedBy);
+		await addUserToEntity(invite.to, inviteEntity.id, defaultRole.id)
 
 		try {
 			await sendEmail(

src/pages/api/invites/index.ts

@@ -8,6 +8,8 @@ import client from "@/lib/mongodb";
 import {withIronSessionApiRoute} from "iron-session/next";
 import type {NextApiRequest, NextApiResponse} from "next";
 import ShortUniqueId from "short-unique-id";
+import { Entity } from "@/interfaces/entity";
+import { getEntity } from "@/utils/entities.be";
 
 const db = client.db(process.env.MONGODB_DB);
 
@@ -36,20 +38,19 @@ async function post(req: NextApiRequest, res: NextApiResponse) {
 	const invited = await db.collection("users").findOne<User>({ id: body.to});
 	if (!invited) return res.status(404).json({ok: false});
 
-	const invitedBy = await db.collection("users").findOne<User>({ id: body.from});
+	const entity = await getEntity(body.entity)
-	if (!invitedBy) return res.status(404).json({ok: false});
+	if (!entity) return res.status(404).json({ok: false});
 
 	try {
 		await sendEmail(
 			"receivedInvite",
 			{
 				name: invited.name,
-				corporateName:
+				entity: entity.label,
-					invitedBy.type === "corporate" ? invitedBy.corporateInformation?.companyInformation?.name || invitedBy.name : invitedBy.name,
 				environment: process.env.ENVIRONMENT,
 			},
 			[invited.email],
-			"You have been invited to a group!",
+			"You have been invited to an entity!",
 		);
 	} catch (e) {
 		console.log(e);

src/pages/dashboard/student.tsx

@@ -9,7 +9,7 @@ import {Session} from "@/hooks/useSessions";
 import {Grading} from "@/interfaces";
 import {EntityWithRoles} from "@/interfaces/entity";
 import {Exam} from "@/interfaces/exam";
-import {InviteWithUsers} from "@/interfaces/invite";
+import { InviteWithEntity } from "@/interfaces/invite";
 import {Assignment} from "@/interfaces/results";
 import {Stat, User} from "@/interfaces/user";
 import {sessionOptions} from "@/lib/session";
@@ -21,7 +21,7 @@ import {getAssignmentsByAssignee} from "@/utils/assignments.be";
 import {getEntitiesWithRoles, getEntityWithRoles} from "@/utils/entities.be";
 import {getExamsByIds} from "@/utils/exams.be";
 import {getGradingSystemByEntity} from "@/utils/grading.be";
-import {convertInvitersToUsers, getInvitesByInvitee} from "@/utils/invites.be";
+import {convertInvitersToEntity, getInvitesByInvitee} from "@/utils/invites.be";
 import {countExamModules, countFullExams, MODULE_ARRAY, sortByModule, sortByModuleName} from "@/utils/moduleUtils";
 import {checkAccess} from "@/utils/permissions";
 import {getGradingLabel} from "@/utils/score";
@@ -45,7 +45,7 @@ interface Props {
 	stats: Stat[];
 	exams: Exam[];
 	sessions: Session[];
-	invites: InviteWithUsers[];
+	invites: InviteWithEntity[];
 	grading: Grading;
 }
 
@@ -65,7 +65,7 @@ export const getServerSideProps = withIronSessionSsr(async ({req, res}) => {
 	const invites = await getInvitesByInvitee(user.id);
 	const grading = await getGradingSystemByEntity(entityIDS[0] || "");
 
-	const formattedInvites = await Promise.all(invites.map(convertInvitersToUsers));
+	const formattedInvites = await Promise.all(invites.map(convertInvitersToEntity));
 
 	const examIDs = uniqBy(
 		assignments.flatMap((a) =>

src/pages/settings.tsx

@@ -43,21 +43,22 @@ export const getServerSideProps = withIronSessionSsr(async ({ req, res }) => {
 
   const permissions = await getUserPermissions(user.id);
   const entities = isAdmin(user) ? await getEntitiesWithRoles() : await getEntitiesWithRoles(mapBy(user.entities, 'id'))
+  const allUsers = await getUsers()
 
   return {
-    props: serialize({ user, permissions, entities }),
+    props: serialize({ user, permissions, entities, allUsers }),
   };
 }, sessionOptions);
 
 interface Props {
   user: User;
   permissions: PermissionType[];
-  entities: EntityWithRoles[]
+	entities: EntityWithRoles[];
+	allUsers: User[]
 }
 
-export default function Admin({ user, entities, permissions }: Props) {
+export default function Admin({ user, entities, permissions, allUsers }: Props) {
   const { gradingSystem, mutate } = useGradingSystem();
-  const { users } = useUsers();
 
   const [modalOpen, setModalOpen] = useState<string>();
 
@@ -75,16 +76,16 @@ export default function Admin({ user, entities, permissions }: Props) {
       <ToastContainer />
       <Layout user={user} className="gap-6">
         <Modal isOpen={modalOpen === "batchCreateUser"} onClose={() => setModalOpen(undefined)}>
-          <BatchCreateUser user={user} entities={entities}  users={users} permissions={permissions} onFinish={() => setModalOpen(undefined)} />
+          <BatchCreateUser user={user} entities={entities}  users={allUsers} permissions={permissions} onFinish={() => setModalOpen(undefined)} />
         </Modal>
         <Modal isOpen={modalOpen === "batchCreateCode"} onClose={() => setModalOpen(undefined)}>
-          <BatchCodeGenerator user={user} users={users} permissions={permissions} onFinish={() => setModalOpen(undefined)} />
+          <BatchCodeGenerator user={user} users={allUsers} permissions={permissions} onFinish={() => setModalOpen(undefined)} />
         </Modal>
         <Modal isOpen={modalOpen === "createCode"} onClose={() => setModalOpen(undefined)}>
           <CodeGenerator user={user} permissions={permissions} onFinish={() => setModalOpen(undefined)} />
         </Modal>
         <Modal isOpen={modalOpen === "createUser"} onClose={() => setModalOpen(undefined)}>
-          <UserCreator user={user} entities={entities} users={users} permissions={permissions} onFinish={() => setModalOpen(undefined)} />
+          <UserCreator user={user} entities={entities} users={allUsers} permissions={permissions} onFinish={() => setModalOpen(undefined)} />
         </Modal>
         <Modal isOpen={modalOpen === "gradingSystem"} onClose={() => setModalOpen(undefined)}>
           <CorporateGradingSystem

src/utils/invites.be.ts

@@ -1,5 +1,6 @@
 import {Session} from "@/hooks/useSessions";
-import {Invite, InviteWithUsers} from "@/interfaces/invite";
+import { Entity } from "@/interfaces/entity";
+import {Invite, InviteWithEntity} from "@/interfaces/invite";
 import {User} from "@/interfaces/user";
 import client from "@/lib/mongodb";
 
@@ -12,7 +13,7 @@ export const getInvitesByInvitee = async (id: string, limit?: number) =>
 		.limit(limit || 0)
 		.toArray();
 
-export const convertInvitersToUsers = async (invite: Invite): Promise<InviteWithUsers> => ({
+export const convertInvitersToEntity = async (invite: Invite): Promise<InviteWithEntity> => ({
 	...invite,
-	from: (await db.collection("users").findOne<User>({id: invite.from})) ?? undefined,
+	entity: (await db.collection("entities").findOne<Entity>({id: invite.entity })) ?? undefined,
 });