Added the ability to choose between partial and full exams

src/components/Diagnostic.tsx

@@ -36,7 +36,7 @@ export default function Diagnostic({onFinish}: Props) {
 	};
 
 	const selectExam = () => {
-		const examPromises = MODULE_ARRAY.map((module) => getExam(module, true));
+		const examPromises = MODULE_ARRAY.map((module) => getExam(module, true, "partial"));
 
 		Promise.all(examPromises).then((exams) => {
 			if (exams.every((x) => !!x)) {

src/exams/Selection.tsx

@@ -12,17 +12,19 @@ import {calculateAverageLevel} from "@/utils/score";
 import {sortByModuleName} from "@/utils/moduleUtils";
 import {capitalize} from "lodash";
 import ProfileSummary from "@/components/ProfileSummary";
+import {Variant} from "@/interfaces/exam";
 
 interface Props {
 	user: User;
 	page: "exercises" | "exams";
-	onStart: (modules: Module[], avoidRepeated: boolean) => void;
+	onStart: (modules: Module[], avoidRepeated: boolean, variant: Variant) => void;
 	disableSelection?: boolean;
 }
 
 export default function Selection({user, page, onStart, disableSelection = false}: Props) {
 	const [selectedModules, setSelectedModules] = useState<Module[]>([]);
 	const [avoidRepeatedExams, setAvoidRepeatedExams] = useState(true);
+	const [variant, setVariant] = useState<Variant>("full");
 	const {stats} = useStats(user?.id);
 
 	const toggleModule = (module: Module) => {
@@ -202,9 +204,9 @@ export default function Selection({user, page, onStart, disableSelection = false
 					)}
 				</section>
 				<div className="flex w-full -md:flex-col -md:gap-4 -md:justify-center md:justify-between items-center">
+					<div className="flex flex-col gap-3 items-center w-full">
 						<div
-						className="flex gap-3 items-center text-mti-gray-dim text-sm cursor-pointer tooltip w-full -md:justify-center"
+							className="flex gap-3 items-center text-mti-gray-dim text-sm cursor-pointer w-full -md:justify-center"
-						data-tip="If possible, the platform will choose exams not yet done"
 							onClick={() => setAvoidRepeatedExams((prev) => !prev)}>
 							<input type="checkbox" className="hidden" />
 							<div
@@ -215,7 +217,24 @@ export default function Selection({user, page, onStart, disableSelection = false
 								)}>
 								<BsCheck color="white" className="w-full h-full" />
 							</div>
-						<span>Avoid Repeated Questions</span>
+							<span className="tooltip" data-tip="If possible, the platform will choose exams not yet done.">
+								Avoid Repeated Questions
+							</span>
+						</div>
+						<div
+							className="flex gap-3 items-center text-mti-gray-dim text-sm cursor-pointer  w-full -md:justify-center"
+							onClick={() => setVariant((prev) => (prev === "full" ? "partial" : "full"))}>
+							<input type="checkbox" className="hidden" />
+							<div
+								className={clsx(
+									"w-6 h-6 rounded-md flex items-center justify-center border border-mti-purple-light bg-white",
+									"transition duration-300 ease-in-out",
+									variant === "full" && "!bg-mti-purple-light ",
+								)}>
+								<BsCheck color="white" className="w-full h-full" />
+							</div>
+							<span>Full length exams</span>
+						</div>
 					</div>
 					<div className="tooltip w-full" data-tip={`Your screen size is too small to do ${page}`}>
 						<Button color="purple" className="px-12 w-full max-w-xs md:hidden" disabled>
@@ -227,6 +246,7 @@ export default function Selection({user, page, onStart, disableSelection = false
 							onStart(
 								!disableSelection ? selectedModules.sort(sortByModuleName) : ["reading", "listening", "writing", "speaking"],
 								avoidRepeatedExams,
+								variant,
 							)
 						}
 						color="purple"

src/pages/(exam)/ExamPage.tsx

@@ -5,7 +5,7 @@ import {Module} from "@/interfaces";
 
 import Selection from "@/exams/Selection";
 import Reading from "@/exams/Reading";
-import {Exam, InteractiveSpeakingExercise, SpeakingExercise, UserSolution, WritingExercise} from "@/interfaces/exam";
+import {Exam, InteractiveSpeakingExercise, SpeakingExercise, UserSolution, Variant, WritingExercise} from "@/interfaces/exam";
 import Listening from "@/exams/Listening";
 import Writing from "@/exams/Writing";
 import {ToastContainer, toast} from "react-toastify";
@@ -38,6 +38,7 @@ export default function ExamPage({page}: Props) {
 	const [avoidRepeated, setAvoidRepeated] = useState(false);
 	const [timeSpent, setTimeSpent] = useState(0);
 	const [statsAwaitingEvaluation, setStatsAwaitingEvaluation] = useState<string[]>([]);
+	const [variant, setVariant] = useState<Variant>("full");
 
 	const [exams, setExams] = useExamStore((state) => [state.exams, state.setExams]);
 	const [userSolutions, setUserSolutions] = useExamStore((state) => [state.userSolutions, state.setUserSolutions]);
@@ -84,7 +85,7 @@ export default function ExamPage({page}: Props) {
 	useEffect(() => {
 		(async () => {
 			if (selectedModules.length > 0 && exams.length === 0) {
-				const examPromises = selectedModules.map((module) => getExam(module, avoidRepeated));
+				const examPromises = selectedModules.map((module) => getExam(module, avoidRepeated, variant));
 				Promise.all(examPromises).then((values) => {
 					if (values.every((x) => !!x)) {
 						setExams(values.map((x) => x!));
@@ -253,10 +254,11 @@ export default function ExamPage({page}: Props) {
 					page={page}
 					user={user!}
 					disableSelection={page === "exams"}
-					onStart={(modules, avoid) => {
+					onStart={(modules: Module[], avoid: boolean, variant: Variant) => {
 						setModuleIndex(0);
 						setAvoidRepeated(avoid);
 						setSelectedModules(modules);
+						setVariant(variant);
 					}}
 				/>
 			);

src/pages/(generation)/SpeakingGeneration.tsx

@@ -8,7 +8,7 @@ import {Tab} from "@headlessui/react";
 import axios from "axios";
 import clsx from "clsx";
 import {useRouter} from "next/router";
-import {useState} from "react";
+import {useEffect, useState} from "react";
 import {BsArrowRepeat, BsCheck} from "react-icons/bs";
 import {toast} from "react-toastify";
 
@@ -103,6 +103,11 @@ const SpeakingGeneration = () => {
 	const [isLoading, setIsLoading] = useState(false);
 	const [resultingExam, setResultingExam] = useState<SpeakingExam>();
 
+	useEffect(() => {
+		const parts = [part1, part2, part3].filter((x) => !!x);
+		setMinTimer(parts.length === 0 ? 5 : parts.length * 5);
+	}, [part1, part2, part3]);
+
 	const router = useRouter();
 
 	const setExams = useExamStore((state) => state.setExams);
@@ -162,7 +167,7 @@ const SpeakingGeneration = () => {
 				<Input
 					type="number"
 					name="minTimer"
-					onChange={(e) => setMinTimer(parseInt(e) < 15 ? 15 : parseInt(e))}
+					onChange={(e) => setMinTimer(parseInt(e) < 5 ? 5 : parseInt(e))}
 					value={minTimer}
 					className="max-w-[300px]"
 				/>

src/pages/api/exam/[module]/index.ts

@@ -4,8 +4,8 @@ import {app} from "@/firebase";
 import {getFirestore, setDoc, doc} from "firebase/firestore";
 import {withIronSessionApiRoute} from "iron-session/next";
 import {sessionOptions} from "@/lib/session";
-import {Exam} from "@/interfaces/exam";
+import {Exam, Variant} from "@/interfaces/exam";
-import { getExams } from "@/utils/exams.be";
+import {getExams} from "@/utils/exams.be";
 const db = getFirestore(app);
 
 export default withIronSessionApiRoute(handler, sessionOptions);
@@ -23,12 +23,9 @@ async function GET(req: NextApiRequest, res: NextApiResponse) {
 		return;
 	}
 
-	const {
+	const {module, avoidRepeated, variant} = req.query as {module: string; avoidRepeated: string; variant?: Variant};
-		module,
-		avoidRepeated,
-	} = req.query as {module: string; avoidRepeated: string};
 
-	const exams: Exam[] = await getExams(db, module, avoidRepeated, req.session.user.id);
+	const exams: Exam[] = await getExams(db, module, avoidRepeated, req.session.user.id, variant);
 	res.status(200).json(exams);
 }
 

src/utils/exams.be.ts

@@ -1,15 +1,7 @@
-import {
+import {collection, getDocs, query, where, setDoc, doc, Firestore} from "firebase/firestore";
-  collection,
+import {shuffle} from "lodash";
-  getDocs,
+import {Exam, Variant} from "@/interfaces/exam";
-  query,
+import {Stat} from "@/interfaces/user";
-  where,
-  setDoc,
-  doc,
-  Firestore,
-} from "firebase/firestore";
-import { shuffle } from "lodash";
-import { Exam } from "@/interfaces/exam";
-import { Stat } from "@/interfaces/user";
 
 export const getExams = async (
 	db: Firestore,
@@ -18,20 +10,24 @@ export const getExams = async (
 	// added userId as due to assignments being set from the teacher to the student
 	// we need to make sure we are serving exams not executed by the user and not
 	// by the teacher that performed the request
-  userId: string | undefined
+	userId: string | undefined,
+	variant?: Variant,
 ): Promise<Exam[]> => {
 	const moduleRef = collection(db, module);
 
 	const q = query(moduleRef, where("isDiagnostic", "==", false));
 	const snapshot = await getDocs(q);
 
-  const exams: Exam[] = shuffle(
+	const exams: Exam[] = filterByVariant(
+		shuffle(
 			snapshot.docs.map((doc) => ({
 				id: doc.id,
 				...doc.data(),
 				module,
-    }))
+			})),
-  ) as Exam[];
+		) as Exam[],
+		variant,
+	);
 
 	if (avoidRepeated === "true") {
 		const statsQ = query(collection(db, "stats"), where("user", "==", userId));
@@ -41,12 +37,15 @@ export const getExams = async (
 			id: doc.id,
 			...doc.data(),
 		})) as unknown as Stat[];
-    const filteredExams = exams.filter(
+		const filteredExams = exams.filter((x) => !stats.map((s) => s.exam).includes(x.id));
-      (x) => !stats.map((s) => s.exam).includes(x.id)
-    );
 
 		return filteredExams.length > 0 ? filteredExams : exams;
 	}
 
 	return exams;
 };
+
+const filterByVariant = (exams: Exam[], variant?: Variant) => {
+	const filtered = variant && variant === "partial" ? exams.filter((x) => x.variant === "partial") : exams;
+	return filtered.length > 0 ? filtered : exams;
+};

src/utils/exams.ts

@@ -1,9 +1,13 @@
 import {Module} from "@/interfaces";
-import {Exam, ReadingExam, ListeningExam, WritingExam, SpeakingExam, Exercise, UserSolution, LevelExam} from "@/interfaces/exam";
+import {Exam, ReadingExam, ListeningExam, WritingExam, SpeakingExam, Exercise, UserSolution, LevelExam, Variant} from "@/interfaces/exam";
 import axios from "axios";
 
-export const getExam = async (module: Module, avoidRepeated: boolean): Promise<Exam | undefined> => {
+export const getExam = async (module: Module, avoidRepeated: boolean, variant?: Variant): Promise<Exam | undefined> => {
-	const examRequest = await axios<Exam[]>(`/api/exam/${module}?avoidRepeated=${avoidRepeated}`);
+	const url = new URLSearchParams();
+	url.append("avoidRepeated", avoidRepeated.toString());
+	if (variant) url.append("variant", variant);
+
+	const examRequest = await axios<Exam[]>(`/api/exam/${module}?${url.toString()}`);
 	if (examRequest.status !== 200) {
 		return undefined;
 	}