feat: optionally allow assistants to take the quiz too

assistants are defined by being part of an Intra group with a specific id, set in .env

Author: FreekBes

.env.example

@@ -5,8 +5,13 @@ INTRA_API_UID=enter_your_uid_here
 INTRA_API_SECRET=enter_your_secret_here
 INTRA_CAMPUS_ID=14
 INTRA_CURSUS_ID=21
+INTRA_ASSISTANT_GROUP_ID=68
 INTRA_TEST_ACCOUNTS=karthur,ctest,moretestinglogins
 
+# Whether or not assistants can join the Coalition System and choose a coalition
+# They can never gain points though, only join a coalition
+ASSISTANTS_CAN_QUIZ=false
+
 POSTGRES_USER=enter_a_postgres_user_here
 POSTGRES_PASSWORD=enter_a_postgres_password_here
 POSTGRES_DB=coal

prisma/migrations/20260113155524_add_intra_groups/migration.sql

@@ -0,0 +1,22 @@
+-- CreateTable
+CREATE TABLE "IntraGroup" (
+    "id" INTEGER NOT NULL,
+    "name" TEXT NOT NULL,
+
+    CONSTRAINT "IntraGroup_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "IntraGroupUser" (
+    "id" INTEGER NOT NULL,
+    "group_id" INTEGER NOT NULL,
+    "user_id" INTEGER NOT NULL,
+
+    CONSTRAINT "IntraGroupUser_pkey" PRIMARY KEY ("id")
+);
+
+-- AddForeignKey
+ALTER TABLE "IntraGroupUser" ADD CONSTRAINT "IntraGroupUser_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "IntraUser"("id") ON DELETE RESTRICT ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "IntraGroupUser" ADD CONSTRAINT "IntraGroupUser_group_id_fkey" FOREIGN KEY ("group_id") REFERENCES "IntraGroup"("id") ON DELETE RESTRICT ON UPDATE CASCADE;

prisma/schema.prisma

@@ -246,6 +246,7 @@ model IntraUser {
 	// Relations
 	coalition_users  IntraCoalitionUser[]
 	cursus_users     IntraCursusUser[]
+	group_users      IntraGroupUser[]
 
 	// Codam
 	codam_user      CodamUser?
@@ -323,6 +324,29 @@ model IntraCoalitionUser {
 	coalition        IntraCoalition   @relation(fields: [coalition_id], references: [id], onDelete: Cascade, onUpdate: Cascade)
 }
 
+// Intra Group
+model IntraGroup {
+	id               Int      @id
+	name             String
+
+	// Relations
+	group_users      IntraGroupUser[]
+}
+
+// Intra Group User
+// Links a user to a group
+model IntraGroupUser {
+	id               Int      @id
+	group_id         Int      @map("group_id")
+	user_id          Int      @map("user_id")
+
+	// Relations
+	user             IntraUser    @relation(fields: [user_id], references: [id])
+	group            IntraGroup   @relation(fields: [group_id], references: [id])
+}
+
+// Intra Cursus User
+// Links a user to a cursus
 model IntraCursusUser {
 	id               Int      @id
 	cursus_id        Int      @map("cursus_id")

src/env.ts

@@ -7,7 +7,9 @@ export const INTRA_API_UID = process.env.INTRA_API_UID!;
 export const INTRA_API_SECRET = process.env.INTRA_API_SECRET!;
 export const CAMPUS_ID: number = parseInt(process.env.INTRA_CAMPUS_ID!);
 export const CURSUS_ID: number = parseInt(process.env.INTRA_CURSUS_ID!);
+export const ASSISTANT_GROUP_ID: number = parseInt(process.env.INTRA_ASSISTANT_GROUP_ID!);
 export const INTRA_TEST_ACCOUNTS: string[] = (process.env.INTRA_TEST_ACCOUNTS || '').split(',');
+export const ASSISTANTS_CAN_QUIZ: boolean = process.env.ASSISTANTS_CAN_QUIZ === 'true';
 
 // Not defined in .env but in regular shell environment variables
 export const DEV_DAYS_LIMIT: number = process.env.DEV_DAYS_LIMIT ? parseInt(process.env.DEV_DAYS_LIMIT) : 365;

src/handlers/authentication.ts

@@ -4,7 +4,7 @@ import OAuth2Strategy from 'passport-oauth2';
 import { PrismaClient } from '@prisma/client';
 import { INTRA_API_UID, INTRA_API_SECRET, URL_ORIGIN, SESSION_SECRET, NODE_ENV } from '../env';
 import { getIntraUser, ExpressIntraUser } from '../sync/oauth';
-import { isStudent, isStaff } from '../utils';
+import { isStudent, isStaff, isAssistant } from '../utils';
 import { PrismaSessionStore } from '@quixo3/prisma-session-store';
 
 export const setupPassport = function(prisma: PrismaClient): void {
@@ -53,6 +53,7 @@ export const setupPassport = function(prisma: PrismaClient): void {
 				kind: user.kind,
 				isStudent: await isStudent(prisma, user),
 				isStaff: await isStaff(user),
+				isAssistant: await isAssistant(prisma, user),
 				image_url: user.image,
 			};
 			cb(null, intraUser);

src/routes/quiz.ts

@@ -7,7 +7,7 @@ import { ExpressIntraUser } from '../sync/oauth';
 import { getAPIClient } from '../utils';
 import { fetchSingle42ApiPage } from '../sync/base';
 import { syncCoalitionUser } from '../sync/coalitions_users';
-import { CURSUS_ID } from '../env';
+import { ASSISTANTS_CAN_QUIZ, CURSUS_ID } from '../env';
 
 export interface QuizSessionQuestion {
 	question: CodamCoalitionTestQuestion;
@@ -59,11 +59,9 @@ export const isQuizAvailable = async function(user: IntraUser | ExpressIntraUser
 	});
 	const currentDate = new Date();
 	const availableDueToTime = (currentDate.getTime() >= settings.start_at.getTime() && currentDate.getTime() < settings.deadline_at.getTime());
-	if (availableDueToTime) {
-		return true; // Skip any further database queries, the questionnaire is available for everyone!
-	}
 
 	// If the user is not part of any coalition currently, taking the questionnaire is always allowed, as long as their cursus is ongoing
+	// Also allow assistants to take the quiz if the relevant env var is set
 	const userDetails = await prisma.intraUser.findFirst({
 		where: {
 			id: user.id,
@@ -94,13 +92,31 @@ export const isQuizAvailable = async function(user: IntraUser | ExpressIntraUser
 					end_at: true,
 				},
 			},
+			group_users: {
+				select: {
+					id: true,
+				},
+				where: {
+					group_id: parseInt(process.env.INTRA_ASSISTANT_GROUP_ID || '0'),
+				},
+			},
 		},
 	});
 	if (!userDetails) {
 		console.warn(`User ${user.id} not found in database when checking quiz availability`);
 		return false;
 	}
-	return (userDetails.coalition_users.length == 0 && userDetails.cursus_users.length > 0 && !userDetails.cursus_users[0].end_at);
+	if (userDetails.coalition_users.length === 0 || availableDueToTime) {
+		if (userDetails.cursus_users.length > 0 && !userDetails.cursus_users[0].end_at) {
+			console.log(`User ${user.id} has an ongoing cursus in cursus ${CURSUS_ID}, allowing to take the questionnaire`);
+			return true; // User has an ongoing cursus in the relevant cursus, allow taking the questionnaire
+		}
+		if (userDetails.group_users.length > 0 && ASSISTANTS_CAN_QUIZ) {
+			console.log(`User ${user.id} is an assistant and assistants are allowed to take the quiz due to env var ASSISTANTS_CAN_QUIZ, allowing to take the questionnaire`);
+			return true; // User is an assistant and assistants are allowed to take the quiz due to env var ASSISTANTS_CAN_QUIZ
+		}
+	}
+	return false;
 }
 
 const resetQuizSession = async function(req: Request, userSession: CustomSessionData): Promise<void> {

src/sync/base.ts

@@ -15,6 +15,7 @@ import { getBlocAtDate } from '../utils';
 import { handleRankingTitleCreation, handleRankingBonuses } from './rankings';
 import { syncTitles } from './titles';
 import { calculateResults } from './results';
+import { syncGroups, syncGroupsUsers } from './groups';
 
 export const prisma = new PrismaClient();
 
@@ -229,6 +230,8 @@ export const syncWithIntra = async function(api: Fast42): Promise<void> {
 		await syncProjects(api, lastSync, now);
 		await syncUsers(api, lastSync, now);
 		await syncCursusUsers(api, lastSync, now);
+		await syncGroups(api, lastSync, now);
+		await syncGroupsUsers(api, now);
 		await syncBlocs(api, now); // also syncs coalitions
 		await syncCoalitionUsers(api, lastSync, now);
 		await handleRankingTitleCreation(api);

src/sync/groups.ts

@@ -0,0 +1,84 @@
+import Fast42 from '@codam/fast42';
+import { prisma, syncDataCB } from './base';
+import { ASSISTANT_GROUP_ID } from '../env';
+
+export const syncGroups = async function(api: Fast42, syncSince: Date, syncDate: Date): Promise<void> {
+	// We only sync the assistant group (id defined in ASSISTANT_GROUP_ID)
+	await syncDataCB(api, syncDate, syncSince, `/groups/${ASSISTANT_GROUP_ID}`, {}, async (group) => {
+		try {
+			await prisma.intraGroup.upsert({
+				where: {
+					id: group.id,
+				},
+				update: {
+					name: group.name,
+				},
+				create: {
+					id: group.id,
+					name: group.name,
+				}
+			});
+		}
+		catch (err) {
+			console.error(`Error syncing group ${group.id}: ${err}`);
+		}
+	});
+};
+
+export const syncGroupsUsers = async function(api: Fast42, syncDate: Date): Promise<void> {
+	const groups = await prisma.intraGroup.findMany({});
+
+	for (const group of groups) {
+		await syncDataCB(api, syncDate, undefined, `/groups/${group.id}/groups_users`, {}, async (groupsUsers) => {
+			// Delete all group_users
+			await prisma.intraGroupUser.deleteMany({
+				where: {
+					group_id: group.id,
+				},
+			});
+
+			for (const groupUser of groupsUsers) {
+				console.debug(`Syncing a group_user (user ${groupUser.user_id} in group "${groupUser.group.name}")...`);
+
+				try {
+					const user = await prisma.intraUser.findFirst({
+						where: {
+							id: groupUser.user_id,
+						},
+						select: {
+							id: true, // Minimal select to check if user exists
+						},
+					});
+					if (!user) {
+						continue; // User is likely not from our campus
+					}
+
+					await prisma.intraGroupUser.upsert({
+						where: {
+							id: groupUser.id,
+						},
+						update: {
+							user_id: groupUser.user_id,
+						},
+						create: {
+							id: groupUser.id,
+							user: {
+								connect: {
+									id: groupUser.user_id,
+								},
+							},
+							group: {
+								connect: {
+									id: groupUser.group.id,
+								},
+							},
+						}
+					});
+				}
+				catch (err) {
+					console.error(`Error syncing group_user ${groupUser.id}: ${err}`);
+				}
+			}
+		});
+	}
+};

src/sync/oauth.ts

@@ -1,6 +1,6 @@
 import https from 'https';
 import { CAMPUS_ID } from '../env';
-import { isStudent, isStaff } from '../utils';
+import { isStudent, isStaff, isAssistant } from '../utils';
 import { prisma } from './base';
 
 export interface ExpressIntraUser extends Express.User {
@@ -13,8 +13,9 @@ export interface ExpressIntraUser extends Express.User {
 	usual_full_name: string;
 	display_name: string;
 	kind: string;
-	isStudent: boolean; // can be false for pisciners
+	isStudent: boolean; // true if the user is active in the CURSUS_ID cursus
 	isStaff: boolean;
+	isAssistant: boolean; // true if the user is part of the ASSISTANT_GROUP_ID group on Intra (C.A.T. team)
 	image_url: string | null;
 };
 
@@ -65,6 +66,7 @@ export const getIntraUser = async function(accessToken: string): Promise<Express
 			kind: me.kind,
 			isStudent: await isStudent(prisma, me),
 			isStaff: await isStaff(me),
+			isAssistant: await isAssistant(prisma, me),
 			image_url: (me.image && me.image.link ? me.image.versions.medium : null),
 		};
 

src/utils.ts

@@ -2,7 +2,7 @@ import { PrismaClient, IntraUser, IntraCoalition, IntraBlocDeadline, CodamCoalit
 import { ExpressIntraUser } from "./sync/oauth";
 import Fast42 from "@codam/fast42";
 import { api } from "./main";
-import { CURSUS_ID } from "./env";
+import { ASSISTANT_GROUP_ID, CURSUS_ID } from "./env";
 import NodeCache from "node-cache";
 import { Request } from "express";
 
@@ -78,6 +78,19 @@ export const isStaff = async function(intraUser: ExpressIntraUser | IntraUser):
 	return intraUser.kind === 'admin';
 };
 
+export const isAssistant = async function(prisma: PrismaClient, intraUser: ExpressIntraUser | IntraUser): Promise<boolean> {
+	if (isNaN(ASSISTANT_GROUP_ID)) {
+		return false;
+	}
+	const groupUser = await prisma.intraGroupUser.findFirst({
+		where: {
+			group_id: ASSISTANT_GROUP_ID,
+			user_id: intraUser.id,
+		},
+	});
+	return (groupUser !== null);
+};
+
 export const getCoalitionIds = async function(prisma: PrismaClient): Promise<any> {
 	const coalitionIds = await prisma.intraCoalition.findMany({
 		select: {